Google Git
Sign in
fuchsia / third_party / Vulkan-ValidationLayers / refs/tags/v1.2.177 / . / layers / generated / vk_safe_struct.cpp
blob: 71a0f7dae6570d161b95fad4178d65c51c29c7f2 [file] [log] [blame]
// *** THIS FILE IS GENERATED - DO NOT EDIT ***
// See helper_file_generator.py for modifications
/***************************************************************************
*
* Copyright (c) 2015-2021 The Khronos Group Inc.
* Copyright (c) 2015-2021 Valve Corporation
* Copyright (c) 2015-2021 LunarG, Inc.
* Copyright (c) 2015-2021 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>
*
****************************************************************************/
#include "vk_safe_struct.h"
#include <string.h>
#include <cassert>
#include <cstring>
#include <vector>
#include <vulkan/vk_layer.h>
extern std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info;
safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct) :
sType(in_struct->sType),
srcAccessMask(in_struct->srcAccessMask),
dstAccessMask(in_struct->dstAccessMask),
srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
buffer(in_struct->buffer),
offset(in_struct->offset),
size(in_struct->size)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier() :
sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER),
pNext(nullptr)
{}
safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src)
{
sType = copy_src.sType;
srcAccessMask = copy_src.srcAccessMask;
dstAccessMask = copy_src.dstAccessMask;
srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
buffer = copy_src.buffer;
offset = copy_src.offset;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferMemoryBarrier& safe_VkBufferMemoryBarrier::operator=(const safe_VkBufferMemoryBarrier& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcAccessMask = copy_src.srcAccessMask;
dstAccessMask = copy_src.dstAccessMask;
srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
buffer = copy_src.buffer;
offset = copy_src.offset;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferMemoryBarrier::~safe_VkBufferMemoryBarrier()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferMemoryBarrier::initialize(const VkBufferMemoryBarrier* in_struct)
{
sType = in_struct->sType;
srcAccessMask = in_struct->srcAccessMask;
dstAccessMask = in_struct->dstAccessMask;
srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
buffer = in_struct->buffer;
offset = in_struct->offset;
size = in_struct->size;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* copy_src)
{
sType = copy_src->sType;
srcAccessMask = copy_src->srcAccessMask;
dstAccessMask = copy_src->dstAccessMask;
srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
buffer = copy_src->buffer;
offset = copy_src->offset;
size = copy_src->size;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct) :
sType(in_struct->sType),
srcAccessMask(in_struct->srcAccessMask),
dstAccessMask(in_struct->dstAccessMask),
oldLayout(in_struct->oldLayout),
newLayout(in_struct->newLayout),
srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
image(in_struct->image),
subresourceRange(in_struct->subresourceRange)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier() :
sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER),
pNext(nullptr)
{}
safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src)
{
sType = copy_src.sType;
srcAccessMask = copy_src.srcAccessMask;
dstAccessMask = copy_src.dstAccessMask;
oldLayout = copy_src.oldLayout;
newLayout = copy_src.newLayout;
srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
image = copy_src.image;
subresourceRange = copy_src.subresourceRange;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageMemoryBarrier& safe_VkImageMemoryBarrier::operator=(const safe_VkImageMemoryBarrier& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcAccessMask = copy_src.srcAccessMask;
dstAccessMask = copy_src.dstAccessMask;
oldLayout = copy_src.oldLayout;
newLayout = copy_src.newLayout;
srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
image = copy_src.image;
subresourceRange = copy_src.subresourceRange;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageMemoryBarrier::~safe_VkImageMemoryBarrier()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageMemoryBarrier::initialize(const VkImageMemoryBarrier* in_struct)
{
sType = in_struct->sType;
srcAccessMask = in_struct->srcAccessMask;
dstAccessMask = in_struct->dstAccessMask;
oldLayout = in_struct->oldLayout;
newLayout = in_struct->newLayout;
srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
image = in_struct->image;
subresourceRange = in_struct->subresourceRange;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* copy_src)
{
sType = copy_src->sType;
srcAccessMask = copy_src->srcAccessMask;
dstAccessMask = copy_src->dstAccessMask;
oldLayout = copy_src->oldLayout;
newLayout = copy_src->newLayout;
srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
image = copy_src->image;
subresourceRange = copy_src->subresourceRange;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryBarrier::safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct) :
sType(in_struct->sType),
srcAccessMask(in_struct->srcAccessMask),
dstAccessMask(in_struct->dstAccessMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryBarrier::safe_VkMemoryBarrier() :
sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER),
pNext(nullptr)
{}
safe_VkMemoryBarrier::safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src)
{
sType = copy_src.sType;
srcAccessMask = copy_src.srcAccessMask;
dstAccessMask = copy_src.dstAccessMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryBarrier& safe_VkMemoryBarrier::operator=(const safe_VkMemoryBarrier& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcAccessMask = copy_src.srcAccessMask;
dstAccessMask = copy_src.dstAccessMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryBarrier::~safe_VkMemoryBarrier()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryBarrier::initialize(const VkMemoryBarrier* in_struct)
{
sType = in_struct->sType;
srcAccessMask = in_struct->srcAccessMask;
dstAccessMask = in_struct->dstAccessMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryBarrier::initialize(const safe_VkMemoryBarrier* copy_src)
{
sType = copy_src->sType;
srcAccessMask = copy_src->srcAccessMask;
dstAccessMask = copy_src->dstAccessMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct) :
pUserData(in_struct->pUserData),
pfnAllocation(in_struct->pfnAllocation),
pfnReallocation(in_struct->pfnReallocation),
pfnFree(in_struct->pfnFree),
pfnInternalAllocation(in_struct->pfnInternalAllocation),
pfnInternalFree(in_struct->pfnInternalFree)
{
}
safe_VkAllocationCallbacks::safe_VkAllocationCallbacks() :
pUserData(nullptr)
{}
safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& copy_src)
{
pUserData = copy_src.pUserData;
pfnAllocation = copy_src.pfnAllocation;
pfnReallocation = copy_src.pfnReallocation;
pfnFree = copy_src.pfnFree;
pfnInternalAllocation = copy_src.pfnInternalAllocation;
pfnInternalFree = copy_src.pfnInternalFree;
}
safe_VkAllocationCallbacks& safe_VkAllocationCallbacks::operator=(const safe_VkAllocationCallbacks& copy_src)
{
if (&copy_src == this) return *this;
pUserData = copy_src.pUserData;
pfnAllocation = copy_src.pfnAllocation;
pfnReallocation = copy_src.pfnReallocation;
pfnFree = copy_src.pfnFree;
pfnInternalAllocation = copy_src.pfnInternalAllocation;
pfnInternalFree = copy_src.pfnInternalFree;
return *this;
}
safe_VkAllocationCallbacks::~safe_VkAllocationCallbacks()
{
}
void safe_VkAllocationCallbacks::initialize(const VkAllocationCallbacks* in_struct)
{
pUserData = in_struct->pUserData;
pfnAllocation = in_struct->pfnAllocation;
pfnReallocation = in_struct->pfnReallocation;
pfnFree = in_struct->pfnFree;
pfnInternalAllocation = in_struct->pfnInternalAllocation;
pfnInternalFree = in_struct->pfnInternalFree;
}
void safe_VkAllocationCallbacks::initialize(const safe_VkAllocationCallbacks* copy_src)
{
pUserData = copy_src->pUserData;
pfnAllocation = copy_src->pfnAllocation;
pfnReallocation = copy_src->pfnReallocation;
pfnFree = copy_src->pfnFree;
pfnInternalAllocation = copy_src->pfnInternalAllocation;
pfnInternalFree = copy_src->pfnInternalFree;
}
safe_VkApplicationInfo::safe_VkApplicationInfo(const VkApplicationInfo* in_struct) :
sType(in_struct->sType),
applicationVersion(in_struct->applicationVersion),
engineVersion(in_struct->engineVersion),
apiVersion(in_struct->apiVersion)
{
pNext = SafePnextCopy(in_struct->pNext);
pApplicationName = SafeStringCopy(in_struct->pApplicationName);
pEngineName = SafeStringCopy(in_struct->pEngineName);
}
safe_VkApplicationInfo::safe_VkApplicationInfo() :
sType(VK_STRUCTURE_TYPE_APPLICATION_INFO),
pNext(nullptr),
pApplicationName(nullptr),
pEngineName(nullptr)
{}
safe_VkApplicationInfo::safe_VkApplicationInfo(const safe_VkApplicationInfo& copy_src)
{
sType = copy_src.sType;
applicationVersion = copy_src.applicationVersion;
engineVersion = copy_src.engineVersion;
apiVersion = copy_src.apiVersion;
pNext = SafePnextCopy(copy_src.pNext);
pApplicationName = SafeStringCopy(copy_src.pApplicationName);
pEngineName = SafeStringCopy(copy_src.pEngineName);
}
safe_VkApplicationInfo& safe_VkApplicationInfo::operator=(const safe_VkApplicationInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pApplicationName) delete [] pApplicationName;
if (pEngineName) delete [] pEngineName;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
applicationVersion = copy_src.applicationVersion;
engineVersion = copy_src.engineVersion;
apiVersion = copy_src.apiVersion;
pNext = SafePnextCopy(copy_src.pNext);
pApplicationName = SafeStringCopy(copy_src.pApplicationName);
pEngineName = SafeStringCopy(copy_src.pEngineName);
return *this;
}
safe_VkApplicationInfo::~safe_VkApplicationInfo()
{
if (pApplicationName) delete [] pApplicationName;
if (pEngineName) delete [] pEngineName;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkApplicationInfo::initialize(const VkApplicationInfo* in_struct)
{
sType = in_struct->sType;
applicationVersion = in_struct->applicationVersion;
engineVersion = in_struct->engineVersion;
apiVersion = in_struct->apiVersion;
pNext = SafePnextCopy(in_struct->pNext);
pApplicationName = SafeStringCopy(in_struct->pApplicationName);
pEngineName = SafeStringCopy(in_struct->pEngineName);
}
void safe_VkApplicationInfo::initialize(const safe_VkApplicationInfo* copy_src)
{
sType = copy_src->sType;
applicationVersion = copy_src->applicationVersion;
engineVersion = copy_src->engineVersion;
apiVersion = copy_src->apiVersion;
pNext = SafePnextCopy(copy_src->pNext);
pApplicationName = SafeStringCopy(copy_src->pApplicationName);
pEngineName = SafeStringCopy(copy_src->pEngineName);
}
safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
pApplicationInfo(nullptr),
enabledLayerCount(in_struct->enabledLayerCount),
enabledExtensionCount(in_struct->enabledExtensionCount)
{
pNext = SafePnextCopy(in_struct->pNext);
char **tmp_ppEnabledLayerNames = new char *[in_struct->enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[in_struct->enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (in_struct->pApplicationInfo)
pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo);
}
safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo() :
sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO),
pNext(nullptr),
pApplicationInfo(nullptr),
ppEnabledLayerNames(nullptr),
ppEnabledExtensionNames(nullptr)
{}
safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pApplicationInfo = nullptr;
enabledLayerCount = copy_src.enabledLayerCount;
enabledExtensionCount = copy_src.enabledExtensionCount;
pNext = SafePnextCopy(copy_src.pNext);
char **tmp_ppEnabledLayerNames = new char *[copy_src.enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[copy_src.enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (copy_src.pApplicationInfo)
pApplicationInfo = new safe_VkApplicationInfo(*copy_src.pApplicationInfo);
}
safe_VkInstanceCreateInfo& safe_VkInstanceCreateInfo::operator=(const safe_VkInstanceCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pApplicationInfo)
delete pApplicationInfo;
if (ppEnabledLayerNames) {
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
delete [] ppEnabledLayerNames[i];
}
delete [] ppEnabledLayerNames;
}
if (ppEnabledExtensionNames) {
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
delete [] ppEnabledExtensionNames[i];
}
delete [] ppEnabledExtensionNames;
}
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pApplicationInfo = nullptr;
enabledLayerCount = copy_src.enabledLayerCount;
enabledExtensionCount = copy_src.enabledExtensionCount;
pNext = SafePnextCopy(copy_src.pNext);
char **tmp_ppEnabledLayerNames = new char *[copy_src.enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[copy_src.enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (copy_src.pApplicationInfo)
pApplicationInfo = new safe_VkApplicationInfo(*copy_src.pApplicationInfo);
return *this;
}
safe_VkInstanceCreateInfo::~safe_VkInstanceCreateInfo()
{
if (pApplicationInfo)
delete pApplicationInfo;
if (ppEnabledLayerNames) {
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
delete [] ppEnabledLayerNames[i];
}
delete [] ppEnabledLayerNames;
}
if (ppEnabledExtensionNames) {
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
delete [] ppEnabledExtensionNames[i];
}
delete [] ppEnabledExtensionNames;
}
if (pNext)
FreePnextChain(pNext);
}
void safe_VkInstanceCreateInfo::initialize(const VkInstanceCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pApplicationInfo = nullptr;
enabledLayerCount = in_struct->enabledLayerCount;
enabledExtensionCount = in_struct->enabledExtensionCount;
pNext = SafePnextCopy(in_struct->pNext);
char **tmp_ppEnabledLayerNames = new char *[in_struct->enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[in_struct->enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (in_struct->pApplicationInfo)
pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo);
}
void safe_VkInstanceCreateInfo::initialize(const safe_VkInstanceCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pApplicationInfo = nullptr;
enabledLayerCount = copy_src->enabledLayerCount;
enabledExtensionCount = copy_src->enabledExtensionCount;
pNext = SafePnextCopy(copy_src->pNext);
char **tmp_ppEnabledLayerNames = new char *[copy_src->enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src->ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[copy_src->enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src->ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (copy_src->pApplicationInfo)
pApplicationInfo = new safe_VkApplicationInfo(*copy_src->pApplicationInfo);
}
safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
queueFamilyIndex(in_struct->queueFamilyIndex),
queueCount(in_struct->queueCount),
pQueuePriorities(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pQueuePriorities) {
pQueuePriorities = new float[in_struct->queueCount];
memcpy ((void *)pQueuePriorities, (void *)in_struct->pQueuePriorities, sizeof(float)*in_struct->queueCount);
}
}
safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo() :
sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO),
pNext(nullptr),
pQueuePriorities(nullptr)
{}
safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
queueFamilyIndex = copy_src.queueFamilyIndex;
queueCount = copy_src.queueCount;
pQueuePriorities = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pQueuePriorities) {
pQueuePriorities = new float[copy_src.queueCount];
memcpy ((void *)pQueuePriorities, (void *)copy_src.pQueuePriorities, sizeof(float)*copy_src.queueCount);
}
}
safe_VkDeviceQueueCreateInfo& safe_VkDeviceQueueCreateInfo::operator=(const safe_VkDeviceQueueCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pQueuePriorities)
delete[] pQueuePriorities;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
queueFamilyIndex = copy_src.queueFamilyIndex;
queueCount = copy_src.queueCount;
pQueuePriorities = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pQueuePriorities) {
pQueuePriorities = new float[copy_src.queueCount];
memcpy ((void *)pQueuePriorities, (void *)copy_src.pQueuePriorities, sizeof(float)*copy_src.queueCount);
}
return *this;
}
safe_VkDeviceQueueCreateInfo::~safe_VkDeviceQueueCreateInfo()
{
if (pQueuePriorities)
delete[] pQueuePriorities;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceQueueCreateInfo::initialize(const VkDeviceQueueCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
queueFamilyIndex = in_struct->queueFamilyIndex;
queueCount = in_struct->queueCount;
pQueuePriorities = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pQueuePriorities) {
pQueuePriorities = new float[in_struct->queueCount];
memcpy ((void *)pQueuePriorities, (void *)in_struct->pQueuePriorities, sizeof(float)*in_struct->queueCount);
}
}
void safe_VkDeviceQueueCreateInfo::initialize(const safe_VkDeviceQueueCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
queueFamilyIndex = copy_src->queueFamilyIndex;
queueCount = copy_src->queueCount;
pQueuePriorities = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pQueuePriorities) {
pQueuePriorities = new float[copy_src->queueCount];
memcpy ((void *)pQueuePriorities, (void *)copy_src->pQueuePriorities, sizeof(float)*copy_src->queueCount);
}
}
safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
queueCreateInfoCount(in_struct->queueCreateInfoCount),
pQueueCreateInfos(nullptr),
enabledLayerCount(in_struct->enabledLayerCount),
enabledExtensionCount(in_struct->enabledExtensionCount),
pEnabledFeatures(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
char **tmp_ppEnabledLayerNames = new char *[in_struct->enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[in_struct->enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (queueCreateInfoCount && in_struct->pQueueCreateInfos) {
pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]);
}
}
if (in_struct->pEnabledFeatures) {
pEnabledFeatures = new VkPhysicalDeviceFeatures(*in_struct->pEnabledFeatures);
}
}
safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo() :
sType(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO),
pNext(nullptr),
pQueueCreateInfos(nullptr),
ppEnabledLayerNames(nullptr),
ppEnabledExtensionNames(nullptr),
pEnabledFeatures(nullptr)
{}
safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
queueCreateInfoCount = copy_src.queueCreateInfoCount;
pQueueCreateInfos = nullptr;
enabledLayerCount = copy_src.enabledLayerCount;
enabledExtensionCount = copy_src.enabledExtensionCount;
pEnabledFeatures = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
char **tmp_ppEnabledLayerNames = new char *[copy_src.enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[copy_src.enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (queueCreateInfoCount && copy_src.pQueueCreateInfos) {
pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
pQueueCreateInfos[i].initialize(&copy_src.pQueueCreateInfos[i]);
}
}
if (copy_src.pEnabledFeatures) {
pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src.pEnabledFeatures);
}
}
safe_VkDeviceCreateInfo& safe_VkDeviceCreateInfo::operator=(const safe_VkDeviceCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pQueueCreateInfos)
delete[] pQueueCreateInfos;
if (ppEnabledLayerNames) {
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
delete [] ppEnabledLayerNames[i];
}
delete [] ppEnabledLayerNames;
}
if (ppEnabledExtensionNames) {
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
delete [] ppEnabledExtensionNames[i];
}
delete [] ppEnabledExtensionNames;
}
if (pEnabledFeatures)
delete pEnabledFeatures;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
queueCreateInfoCount = copy_src.queueCreateInfoCount;
pQueueCreateInfos = nullptr;
enabledLayerCount = copy_src.enabledLayerCount;
enabledExtensionCount = copy_src.enabledExtensionCount;
pEnabledFeatures = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
char **tmp_ppEnabledLayerNames = new char *[copy_src.enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[copy_src.enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (queueCreateInfoCount && copy_src.pQueueCreateInfos) {
pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
pQueueCreateInfos[i].initialize(&copy_src.pQueueCreateInfos[i]);
}
}
if (copy_src.pEnabledFeatures) {
pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src.pEnabledFeatures);
}
return *this;
}
safe_VkDeviceCreateInfo::~safe_VkDeviceCreateInfo()
{
if (pQueueCreateInfos)
delete[] pQueueCreateInfos;
if (ppEnabledLayerNames) {
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
delete [] ppEnabledLayerNames[i];
}
delete [] ppEnabledLayerNames;
}
if (ppEnabledExtensionNames) {
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
delete [] ppEnabledExtensionNames[i];
}
delete [] ppEnabledExtensionNames;
}
if (pEnabledFeatures)
delete pEnabledFeatures;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceCreateInfo::initialize(const VkDeviceCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
queueCreateInfoCount = in_struct->queueCreateInfoCount;
pQueueCreateInfos = nullptr;
enabledLayerCount = in_struct->enabledLayerCount;
enabledExtensionCount = in_struct->enabledExtensionCount;
pEnabledFeatures = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
char **tmp_ppEnabledLayerNames = new char *[in_struct->enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[in_struct->enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (queueCreateInfoCount && in_struct->pQueueCreateInfos) {
pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]);
}
}
if (in_struct->pEnabledFeatures) {
pEnabledFeatures = new VkPhysicalDeviceFeatures(*in_struct->pEnabledFeatures);
}
}
void safe_VkDeviceCreateInfo::initialize(const safe_VkDeviceCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
queueCreateInfoCount = copy_src->queueCreateInfoCount;
pQueueCreateInfos = nullptr;
enabledLayerCount = copy_src->enabledLayerCount;
enabledExtensionCount = copy_src->enabledExtensionCount;
pEnabledFeatures = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
char **tmp_ppEnabledLayerNames = new char *[copy_src->enabledLayerCount];
for (uint32_t i = 0; i < enabledLayerCount; ++i) {
tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src->ppEnabledLayerNames[i]);
}
ppEnabledLayerNames = tmp_ppEnabledLayerNames;
char **tmp_ppEnabledExtensionNames = new char *[copy_src->enabledExtensionCount];
for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src->ppEnabledExtensionNames[i]);
}
ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
if (queueCreateInfoCount && copy_src->pQueueCreateInfos) {
pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
pQueueCreateInfos[i].initialize(&copy_src->pQueueCreateInfos[i]);
}
}
if (copy_src->pEnabledFeatures) {
pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src->pEnabledFeatures);
}
}
safe_VkSubmitInfo::safe_VkSubmitInfo(const VkSubmitInfo* in_struct) :
sType(in_struct->sType),
waitSemaphoreCount(in_struct->waitSemaphoreCount),
pWaitSemaphores(nullptr),
pWaitDstStageMask(nullptr),
commandBufferCount(in_struct->commandBufferCount),
pCommandBuffers(nullptr),
signalSemaphoreCount(in_struct->signalSemaphoreCount),
pSignalSemaphores(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
}
}
if (in_struct->pWaitDstStageMask) {
pWaitDstStageMask = new VkPipelineStageFlags[in_struct->waitSemaphoreCount];
memcpy ((void *)pWaitDstStageMask, (void *)in_struct->pWaitDstStageMask, sizeof(VkPipelineStageFlags)*in_struct->waitSemaphoreCount);
}
if (in_struct->pCommandBuffers) {
pCommandBuffers = new VkCommandBuffer[in_struct->commandBufferCount];
memcpy ((void *)pCommandBuffers, (void *)in_struct->pCommandBuffers, sizeof(VkCommandBuffer)*in_struct->commandBufferCount);
}
if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
}
}
}
safe_VkSubmitInfo::safe_VkSubmitInfo() :
sType(VK_STRUCTURE_TYPE_SUBMIT_INFO),
pNext(nullptr),
pWaitSemaphores(nullptr),
pWaitDstStageMask(nullptr),
pCommandBuffers(nullptr),
pSignalSemaphores(nullptr)
{}
safe_VkSubmitInfo::safe_VkSubmitInfo(const safe_VkSubmitInfo& copy_src)
{
sType = copy_src.sType;
waitSemaphoreCount = copy_src.waitSemaphoreCount;
pWaitSemaphores = nullptr;
pWaitDstStageMask = nullptr;
commandBufferCount = copy_src.commandBufferCount;
pCommandBuffers = nullptr;
signalSemaphoreCount = copy_src.signalSemaphoreCount;
pSignalSemaphores = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
}
}
if (copy_src.pWaitDstStageMask) {
pWaitDstStageMask = new VkPipelineStageFlags[copy_src.waitSemaphoreCount];
memcpy ((void *)pWaitDstStageMask, (void *)copy_src.pWaitDstStageMask, sizeof(VkPipelineStageFlags)*copy_src.waitSemaphoreCount);
}
if (copy_src.pCommandBuffers) {
pCommandBuffers = new VkCommandBuffer[copy_src.commandBufferCount];
memcpy ((void *)pCommandBuffers, (void *)copy_src.pCommandBuffers, sizeof(VkCommandBuffer)*copy_src.commandBufferCount);
}
if (signalSemaphoreCount && copy_src.pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = copy_src.pSignalSemaphores[i];
}
}
}
safe_VkSubmitInfo& safe_VkSubmitInfo::operator=(const safe_VkSubmitInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pWaitSemaphores)
delete[] pWaitSemaphores;
if (pWaitDstStageMask)
delete[] pWaitDstStageMask;
if (pCommandBuffers)
delete[] pCommandBuffers;
if (pSignalSemaphores)
delete[] pSignalSemaphores;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
waitSemaphoreCount = copy_src.waitSemaphoreCount;
pWaitSemaphores = nullptr;
pWaitDstStageMask = nullptr;
commandBufferCount = copy_src.commandBufferCount;
pCommandBuffers = nullptr;
signalSemaphoreCount = copy_src.signalSemaphoreCount;
pSignalSemaphores = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
}
}
if (copy_src.pWaitDstStageMask) {
pWaitDstStageMask = new VkPipelineStageFlags[copy_src.waitSemaphoreCount];
memcpy ((void *)pWaitDstStageMask, (void *)copy_src.pWaitDstStageMask, sizeof(VkPipelineStageFlags)*copy_src.waitSemaphoreCount);
}
if (copy_src.pCommandBuffers) {
pCommandBuffers = new VkCommandBuffer[copy_src.commandBufferCount];
memcpy ((void *)pCommandBuffers, (void *)copy_src.pCommandBuffers, sizeof(VkCommandBuffer)*copy_src.commandBufferCount);
}
if (signalSemaphoreCount && copy_src.pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = copy_src.pSignalSemaphores[i];
}
}
return *this;
}
safe_VkSubmitInfo::~safe_VkSubmitInfo()
{
if (pWaitSemaphores)
delete[] pWaitSemaphores;
if (pWaitDstStageMask)
delete[] pWaitDstStageMask;
if (pCommandBuffers)
delete[] pCommandBuffers;
if (pSignalSemaphores)
delete[] pSignalSemaphores;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSubmitInfo::initialize(const VkSubmitInfo* in_struct)
{
sType = in_struct->sType;
waitSemaphoreCount = in_struct->waitSemaphoreCount;
pWaitSemaphores = nullptr;
pWaitDstStageMask = nullptr;
commandBufferCount = in_struct->commandBufferCount;
pCommandBuffers = nullptr;
signalSemaphoreCount = in_struct->signalSemaphoreCount;
pSignalSemaphores = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
}
}
if (in_struct->pWaitDstStageMask) {
pWaitDstStageMask = new VkPipelineStageFlags[in_struct->waitSemaphoreCount];
memcpy ((void *)pWaitDstStageMask, (void *)in_struct->pWaitDstStageMask, sizeof(VkPipelineStageFlags)*in_struct->waitSemaphoreCount);
}
if (in_struct->pCommandBuffers) {
pCommandBuffers = new VkCommandBuffer[in_struct->commandBufferCount];
memcpy ((void *)pCommandBuffers, (void *)in_struct->pCommandBuffers, sizeof(VkCommandBuffer)*in_struct->commandBufferCount);
}
if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
}
}
}
void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* copy_src)
{
sType = copy_src->sType;
waitSemaphoreCount = copy_src->waitSemaphoreCount;
pWaitSemaphores = nullptr;
pWaitDstStageMask = nullptr;
commandBufferCount = copy_src->commandBufferCount;
pCommandBuffers = nullptr;
signalSemaphoreCount = copy_src->signalSemaphoreCount;
pSignalSemaphores = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (waitSemaphoreCount && copy_src->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src->pWaitSemaphores[i];
}
}
if (copy_src->pWaitDstStageMask) {
pWaitDstStageMask = new VkPipelineStageFlags[copy_src->waitSemaphoreCount];
memcpy ((void *)pWaitDstStageMask, (void *)copy_src->pWaitDstStageMask, sizeof(VkPipelineStageFlags)*copy_src->waitSemaphoreCount);
}
if (copy_src->pCommandBuffers) {
pCommandBuffers = new VkCommandBuffer[copy_src->commandBufferCount];
memcpy ((void *)pCommandBuffers, (void *)copy_src->pCommandBuffers, sizeof(VkCommandBuffer)*copy_src->commandBufferCount);
}
if (signalSemaphoreCount && copy_src->pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = copy_src->pSignalSemaphores[i];
}
}
}
safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct) :
sType(in_struct->sType),
memory(in_struct->memory),
offset(in_struct->offset),
size(in_struct->size)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMappedMemoryRange::safe_VkMappedMemoryRange() :
sType(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE),
pNext(nullptr)
{}
safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& copy_src)
{
sType = copy_src.sType;
memory = copy_src.memory;
offset = copy_src.offset;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMappedMemoryRange& safe_VkMappedMemoryRange::operator=(const safe_VkMappedMemoryRange& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memory = copy_src.memory;
offset = copy_src.offset;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMappedMemoryRange::~safe_VkMappedMemoryRange()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMappedMemoryRange::initialize(const VkMappedMemoryRange* in_struct)
{
sType = in_struct->sType;
memory = in_struct->memory;
offset = in_struct->offset;
size = in_struct->size;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMappedMemoryRange::initialize(const safe_VkMappedMemoryRange* copy_src)
{
sType = copy_src->sType;
memory = copy_src->memory;
offset = copy_src->offset;
size = copy_src->size;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct) :
sType(in_struct->sType),
allocationSize(in_struct->allocationSize),
memoryTypeIndex(in_struct->memoryTypeIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo() :
sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO),
pNext(nullptr)
{}
safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& copy_src)
{
sType = copy_src.sType;
allocationSize = copy_src.allocationSize;
memoryTypeIndex = copy_src.memoryTypeIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryAllocateInfo& safe_VkMemoryAllocateInfo::operator=(const safe_VkMemoryAllocateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
allocationSize = copy_src.allocationSize;
memoryTypeIndex = copy_src.memoryTypeIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryAllocateInfo::~safe_VkMemoryAllocateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryAllocateInfo::initialize(const VkMemoryAllocateInfo* in_struct)
{
sType = in_struct->sType;
allocationSize = in_struct->allocationSize;
memoryTypeIndex = in_struct->memoryTypeIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryAllocateInfo::initialize(const safe_VkMemoryAllocateInfo* copy_src)
{
sType = copy_src->sType;
allocationSize = copy_src->allocationSize;
memoryTypeIndex = copy_src->memoryTypeIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct) :
buffer(in_struct->buffer),
bindCount(in_struct->bindCount),
pBinds(nullptr)
{
if (bindCount && in_struct->pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = in_struct->pBinds[i];
}
}
}
safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo() :
pBinds(nullptr)
{}
safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src)
{
buffer = copy_src.buffer;
bindCount = copy_src.bindCount;
pBinds = nullptr;
if (bindCount && copy_src.pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src.pBinds[i];
}
}
}
safe_VkSparseBufferMemoryBindInfo& safe_VkSparseBufferMemoryBindInfo::operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pBinds)
delete[] pBinds;
buffer = copy_src.buffer;
bindCount = copy_src.bindCount;
pBinds = nullptr;
if (bindCount && copy_src.pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src.pBinds[i];
}
}
return *this;
}
safe_VkSparseBufferMemoryBindInfo::~safe_VkSparseBufferMemoryBindInfo()
{
if (pBinds)
delete[] pBinds;
}
void safe_VkSparseBufferMemoryBindInfo::initialize(const VkSparseBufferMemoryBindInfo* in_struct)
{
buffer = in_struct->buffer;
bindCount = in_struct->bindCount;
pBinds = nullptr;
if (bindCount && in_struct->pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = in_struct->pBinds[i];
}
}
}
void safe_VkSparseBufferMemoryBindInfo::initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src)
{
buffer = copy_src->buffer;
bindCount = copy_src->bindCount;
pBinds = nullptr;
if (bindCount && copy_src->pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src->pBinds[i];
}
}
}
safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct) :
image(in_struct->image),
bindCount(in_struct->bindCount),
pBinds(nullptr)
{
if (bindCount && in_struct->pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = in_struct->pBinds[i];
}
}
}
safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo() :
pBinds(nullptr)
{}
safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src)
{
image = copy_src.image;
bindCount = copy_src.bindCount;
pBinds = nullptr;
if (bindCount && copy_src.pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src.pBinds[i];
}
}
}
safe_VkSparseImageOpaqueMemoryBindInfo& safe_VkSparseImageOpaqueMemoryBindInfo::operator=(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pBinds)
delete[] pBinds;
image = copy_src.image;
bindCount = copy_src.bindCount;
pBinds = nullptr;
if (bindCount && copy_src.pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src.pBinds[i];
}
}
return *this;
}
safe_VkSparseImageOpaqueMemoryBindInfo::~safe_VkSparseImageOpaqueMemoryBindInfo()
{
if (pBinds)
delete[] pBinds;
}
void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct)
{
image = in_struct->image;
bindCount = in_struct->bindCount;
pBinds = nullptr;
if (bindCount && in_struct->pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = in_struct->pBinds[i];
}
}
}
void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src)
{
image = copy_src->image;
bindCount = copy_src->bindCount;
pBinds = nullptr;
if (bindCount && copy_src->pBinds) {
pBinds = new VkSparseMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src->pBinds[i];
}
}
}
safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct) :
image(in_struct->image),
bindCount(in_struct->bindCount),
pBinds(nullptr)
{
if (bindCount && in_struct->pBinds) {
pBinds = new VkSparseImageMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = in_struct->pBinds[i];
}
}
}
safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo() :
pBinds(nullptr)
{}
safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src)
{
image = copy_src.image;
bindCount = copy_src.bindCount;
pBinds = nullptr;
if (bindCount && copy_src.pBinds) {
pBinds = new VkSparseImageMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src.pBinds[i];
}
}
}
safe_VkSparseImageMemoryBindInfo& safe_VkSparseImageMemoryBindInfo::operator=(const safe_VkSparseImageMemoryBindInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pBinds)
delete[] pBinds;
image = copy_src.image;
bindCount = copy_src.bindCount;
pBinds = nullptr;
if (bindCount && copy_src.pBinds) {
pBinds = new VkSparseImageMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src.pBinds[i];
}
}
return *this;
}
safe_VkSparseImageMemoryBindInfo::~safe_VkSparseImageMemoryBindInfo()
{
if (pBinds)
delete[] pBinds;
}
void safe_VkSparseImageMemoryBindInfo::initialize(const VkSparseImageMemoryBindInfo* in_struct)
{
image = in_struct->image;
bindCount = in_struct->bindCount;
pBinds = nullptr;
if (bindCount && in_struct->pBinds) {
pBinds = new VkSparseImageMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = in_struct->pBinds[i];
}
}
}
void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemoryBindInfo* copy_src)
{
image = copy_src->image;
bindCount = copy_src->bindCount;
pBinds = nullptr;
if (bindCount && copy_src->pBinds) {
pBinds = new VkSparseImageMemoryBind[bindCount];
for (uint32_t i = 0; i < bindCount; ++i) {
pBinds[i] = copy_src->pBinds[i];
}
}
}
safe_VkBindSparseInfo::safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct) :
sType(in_struct->sType),
waitSemaphoreCount(in_struct->waitSemaphoreCount),
pWaitSemaphores(nullptr),
bufferBindCount(in_struct->bufferBindCount),
pBufferBinds(nullptr),
imageOpaqueBindCount(in_struct->imageOpaqueBindCount),
pImageOpaqueBinds(nullptr),
imageBindCount(in_struct->imageBindCount),
pImageBinds(nullptr),
signalSemaphoreCount(in_struct->signalSemaphoreCount),
pSignalSemaphores(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
}
}
if (bufferBindCount && in_struct->pBufferBinds) {
pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
for (uint32_t i = 0; i < bufferBindCount; ++i) {
pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
}
}
if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
}
}
if (imageBindCount && in_struct->pImageBinds) {
pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
for (uint32_t i = 0; i < imageBindCount; ++i) {
pImageBinds[i].initialize(&in_struct->pImageBinds[i]);
}
}
if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
}
}
}
safe_VkBindSparseInfo::safe_VkBindSparseInfo() :
sType(VK_STRUCTURE_TYPE_BIND_SPARSE_INFO),
pNext(nullptr),
pWaitSemaphores(nullptr),
pBufferBinds(nullptr),
pImageOpaqueBinds(nullptr),
pImageBinds(nullptr),
pSignalSemaphores(nullptr)
{}
safe_VkBindSparseInfo::safe_VkBindSparseInfo(const safe_VkBindSparseInfo& copy_src)
{
sType = copy_src.sType;
waitSemaphoreCount = copy_src.waitSemaphoreCount;
pWaitSemaphores = nullptr;
bufferBindCount = copy_src.bufferBindCount;
pBufferBinds = nullptr;
imageOpaqueBindCount = copy_src.imageOpaqueBindCount;
pImageOpaqueBinds = nullptr;
imageBindCount = copy_src.imageBindCount;
pImageBinds = nullptr;
signalSemaphoreCount = copy_src.signalSemaphoreCount;
pSignalSemaphores = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
}
}
if (bufferBindCount && copy_src.pBufferBinds) {
pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
for (uint32_t i = 0; i < bufferBindCount; ++i) {
pBufferBinds[i].initialize(&copy_src.pBufferBinds[i]);
}
}
if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) {
pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
pImageOpaqueBinds[i].initialize(&copy_src.pImageOpaqueBinds[i]);
}
}
if (imageBindCount && copy_src.pImageBinds) {
pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
for (uint32_t i = 0; i < imageBindCount; ++i) {
pImageBinds[i].initialize(&copy_src.pImageBinds[i]);
}
}
if (signalSemaphoreCount && copy_src.pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = copy_src.pSignalSemaphores[i];
}
}
}
safe_VkBindSparseInfo& safe_VkBindSparseInfo::operator=(const safe_VkBindSparseInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pWaitSemaphores)
delete[] pWaitSemaphores;
if (pBufferBinds)
delete[] pBufferBinds;
if (pImageOpaqueBinds)
delete[] pImageOpaqueBinds;
if (pImageBinds)
delete[] pImageBinds;
if (pSignalSemaphores)
delete[] pSignalSemaphores;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
waitSemaphoreCount = copy_src.waitSemaphoreCount;
pWaitSemaphores = nullptr;
bufferBindCount = copy_src.bufferBindCount;
pBufferBinds = nullptr;
imageOpaqueBindCount = copy_src.imageOpaqueBindCount;
pImageOpaqueBinds = nullptr;
imageBindCount = copy_src.imageBindCount;
pImageBinds = nullptr;
signalSemaphoreCount = copy_src.signalSemaphoreCount;
pSignalSemaphores = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
}
}
if (bufferBindCount && copy_src.pBufferBinds) {
pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
for (uint32_t i = 0; i < bufferBindCount; ++i) {
pBufferBinds[i].initialize(&copy_src.pBufferBinds[i]);
}
}
if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) {
pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
pImageOpaqueBinds[i].initialize(&copy_src.pImageOpaqueBinds[i]);
}
}
if (imageBindCount && copy_src.pImageBinds) {
pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
for (uint32_t i = 0; i < imageBindCount; ++i) {
pImageBinds[i].initialize(&copy_src.pImageBinds[i]);
}
}
if (signalSemaphoreCount && copy_src.pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = copy_src.pSignalSemaphores[i];
}
}
return *this;
}
safe_VkBindSparseInfo::~safe_VkBindSparseInfo()
{
if (pWaitSemaphores)
delete[] pWaitSemaphores;
if (pBufferBinds)
delete[] pBufferBinds;
if (pImageOpaqueBinds)
delete[] pImageOpaqueBinds;
if (pImageBinds)
delete[] pImageBinds;
if (pSignalSemaphores)
delete[] pSignalSemaphores;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBindSparseInfo::initialize(const VkBindSparseInfo* in_struct)
{
sType = in_struct->sType;
waitSemaphoreCount = in_struct->waitSemaphoreCount;
pWaitSemaphores = nullptr;
bufferBindCount = in_struct->bufferBindCount;
pBufferBinds = nullptr;
imageOpaqueBindCount = in_struct->imageOpaqueBindCount;
pImageOpaqueBinds = nullptr;
imageBindCount = in_struct->imageBindCount;
pImageBinds = nullptr;
signalSemaphoreCount = in_struct->signalSemaphoreCount;
pSignalSemaphores = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
}
}
if (bufferBindCount && in_struct->pBufferBinds) {
pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
for (uint32_t i = 0; i < bufferBindCount; ++i) {
pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
}
}
if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
}
}
if (imageBindCount && in_struct->pImageBinds) {
pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
for (uint32_t i = 0; i < imageBindCount; ++i) {
pImageBinds[i].initialize(&in_struct->pImageBinds[i]);
}
}
if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
}
}
}
void safe_VkBindSparseInfo::initialize(const safe_VkBindSparseInfo* copy_src)
{
sType = copy_src->sType;
waitSemaphoreCount = copy_src->waitSemaphoreCount;
pWaitSemaphores = nullptr;
bufferBindCount = copy_src->bufferBindCount;
pBufferBinds = nullptr;
imageOpaqueBindCount = copy_src->imageOpaqueBindCount;
pImageOpaqueBinds = nullptr;
imageBindCount = copy_src->imageBindCount;
pImageBinds = nullptr;
signalSemaphoreCount = copy_src->signalSemaphoreCount;
pSignalSemaphores = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (waitSemaphoreCount && copy_src->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src->pWaitSemaphores[i];
}
}
if (bufferBindCount && copy_src->pBufferBinds) {
pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
for (uint32_t i = 0; i < bufferBindCount; ++i) {
pBufferBinds[i].initialize(&copy_src->pBufferBinds[i]);
}
}
if (imageOpaqueBindCount && copy_src->pImageOpaqueBinds) {
pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
pImageOpaqueBinds[i].initialize(&copy_src->pImageOpaqueBinds[i]);
}
}
if (imageBindCount && copy_src->pImageBinds) {
pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
for (uint32_t i = 0; i < imageBindCount; ++i) {
pImageBinds[i].initialize(&copy_src->pImageBinds[i]);
}
}
if (signalSemaphoreCount && copy_src->pSignalSemaphores) {
pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
pSignalSemaphores[i] = copy_src->pSignalSemaphores[i];
}
}
}
safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkFenceCreateInfo::safe_VkFenceCreateInfo() :
sType(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkFenceCreateInfo& safe_VkFenceCreateInfo::operator=(const safe_VkFenceCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkFenceCreateInfo::~safe_VkFenceCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFenceCreateInfo::initialize(const VkFenceCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkFenceCreateInfo::initialize(const safe_VkFenceCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo() :
sType(VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSemaphoreCreateInfo& safe_VkSemaphoreCreateInfo::operator=(const safe_VkSemaphoreCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSemaphoreCreateInfo::~safe_VkSemaphoreCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSemaphoreCreateInfo::initialize(const VkSemaphoreCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSemaphoreCreateInfo::initialize(const safe_VkSemaphoreCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkEventCreateInfo::safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkEventCreateInfo::safe_VkEventCreateInfo() :
sType(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO),
pNext(nullptr)
{}
safe_VkEventCreateInfo::safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkEventCreateInfo& safe_VkEventCreateInfo::operator=(const safe_VkEventCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkEventCreateInfo::~safe_VkEventCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkEventCreateInfo::initialize(const VkEventCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkEventCreateInfo::initialize(const safe_VkEventCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
queryType(in_struct->queryType),
queryCount(in_struct->queryCount),
pipelineStatistics(in_struct->pipelineStatistics)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo() :
sType(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO),
pNext(nullptr)
{}
safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
queryType = copy_src.queryType;
queryCount = copy_src.queryCount;
pipelineStatistics = copy_src.pipelineStatistics;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkQueryPoolCreateInfo& safe_VkQueryPoolCreateInfo::operator=(const safe_VkQueryPoolCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
queryType = copy_src.queryType;
queryCount = copy_src.queryCount;
pipelineStatistics = copy_src.pipelineStatistics;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkQueryPoolCreateInfo::~safe_VkQueryPoolCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkQueryPoolCreateInfo::initialize(const VkQueryPoolCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
queryType = in_struct->queryType;
queryCount = in_struct->queryCount;
pipelineStatistics = in_struct->pipelineStatistics;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkQueryPoolCreateInfo::initialize(const safe_VkQueryPoolCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
queryType = copy_src->queryType;
queryCount = copy_src->queryCount;
pipelineStatistics = copy_src->pipelineStatistics;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
size(in_struct->size),
usage(in_struct->usage),
sharingMode(in_struct->sharingMode),
queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
pQueueFamilyIndices(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
}
}
safe_VkBufferCreateInfo::safe_VkBufferCreateInfo() :
sType(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO),
pNext(nullptr),
pQueueFamilyIndices(nullptr)
{}
safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
size = copy_src.size;
usage = copy_src.usage;
sharingMode = copy_src.sharingMode;
queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src.pQueueFamilyIndices, sizeof(uint32_t)*copy_src.queueFamilyIndexCount);
}
}
safe_VkBufferCreateInfo& safe_VkBufferCreateInfo::operator=(const safe_VkBufferCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pQueueFamilyIndices)
delete[] pQueueFamilyIndices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
size = copy_src.size;
usage = copy_src.usage;
sharingMode = copy_src.sharingMode;
queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src.pQueueFamilyIndices, sizeof(uint32_t)*copy_src.queueFamilyIndexCount);
}
return *this;
}
safe_VkBufferCreateInfo::~safe_VkBufferCreateInfo()
{
if (pQueueFamilyIndices)
delete[] pQueueFamilyIndices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferCreateInfo::initialize(const VkBufferCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
size = in_struct->size;
usage = in_struct->usage;
sharingMode = in_struct->sharingMode;
queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
}
}
void safe_VkBufferCreateInfo::initialize(const safe_VkBufferCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
size = copy_src->size;
usage = copy_src->usage;
sharingMode = copy_src->sharingMode;
queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src->pQueueFamilyIndices, sizeof(uint32_t)*copy_src->queueFamilyIndexCount);
}
}
safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
buffer(in_struct->buffer),
format(in_struct->format),
offset(in_struct->offset),
range(in_struct->range)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo() :
sType(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO),
pNext(nullptr)
{}
safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
buffer = copy_src.buffer;
format = copy_src.format;
offset = copy_src.offset;
range = copy_src.range;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferViewCreateInfo& safe_VkBufferViewCreateInfo::operator=(const safe_VkBufferViewCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
buffer = copy_src.buffer;
format = copy_src.format;
offset = copy_src.offset;
range = copy_src.range;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferViewCreateInfo::~safe_VkBufferViewCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferViewCreateInfo::initialize(const VkBufferViewCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
buffer = in_struct->buffer;
format = in_struct->format;
offset = in_struct->offset;
range = in_struct->range;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferViewCreateInfo::initialize(const safe_VkBufferViewCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
buffer = copy_src->buffer;
format = copy_src->format;
offset = copy_src->offset;
range = copy_src->range;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageCreateInfo::safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
imageType(in_struct->imageType),
format(in_struct->format),
extent(in_struct->extent),
mipLevels(in_struct->mipLevels),
arrayLayers(in_struct->arrayLayers),
samples(in_struct->samples),
tiling(in_struct->tiling),
usage(in_struct->usage),
sharingMode(in_struct->sharingMode),
queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
pQueueFamilyIndices(nullptr),
initialLayout(in_struct->initialLayout)
{
pNext = SafePnextCopy(in_struct->pNext);
if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
}
}
safe_VkImageCreateInfo::safe_VkImageCreateInfo() :
sType(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO),
pNext(nullptr),
pQueueFamilyIndices(nullptr)
{}
safe_VkImageCreateInfo::safe_VkImageCreateInfo(const safe_VkImageCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
imageType = copy_src.imageType;
format = copy_src.format;
extent = copy_src.extent;
mipLevels = copy_src.mipLevels;
arrayLayers = copy_src.arrayLayers;
samples = copy_src.samples;
tiling = copy_src.tiling;
usage = copy_src.usage;
sharingMode = copy_src.sharingMode;
queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
initialLayout = copy_src.initialLayout;
pNext = SafePnextCopy(copy_src.pNext);
if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src.pQueueFamilyIndices, sizeof(uint32_t)*copy_src.queueFamilyIndexCount);
}
}
safe_VkImageCreateInfo& safe_VkImageCreateInfo::operator=(const safe_VkImageCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pQueueFamilyIndices)
delete[] pQueueFamilyIndices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
imageType = copy_src.imageType;
format = copy_src.format;
extent = copy_src.extent;
mipLevels = copy_src.mipLevels;
arrayLayers = copy_src.arrayLayers;
samples = copy_src.samples;
tiling = copy_src.tiling;
usage = copy_src.usage;
sharingMode = copy_src.sharingMode;
queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
initialLayout = copy_src.initialLayout;
pNext = SafePnextCopy(copy_src.pNext);
if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src.pQueueFamilyIndices, sizeof(uint32_t)*copy_src.queueFamilyIndexCount);
}
return *this;
}
safe_VkImageCreateInfo::~safe_VkImageCreateInfo()
{
if (pQueueFamilyIndices)
delete[] pQueueFamilyIndices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageCreateInfo::initialize(const VkImageCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
imageType = in_struct->imageType;
format = in_struct->format;
extent = in_struct->extent;
mipLevels = in_struct->mipLevels;
arrayLayers = in_struct->arrayLayers;
samples = in_struct->samples;
tiling = in_struct->tiling;
usage = in_struct->usage;
sharingMode = in_struct->sharingMode;
queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
initialLayout = in_struct->initialLayout;
pNext = SafePnextCopy(in_struct->pNext);
if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
}
}
void safe_VkImageCreateInfo::initialize(const safe_VkImageCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
imageType = copy_src->imageType;
format = copy_src->format;
extent = copy_src->extent;
mipLevels = copy_src->mipLevels;
arrayLayers = copy_src->arrayLayers;
samples = copy_src->samples;
tiling = copy_src->tiling;
usage = copy_src->usage;
sharingMode = copy_src->sharingMode;
queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
initialLayout = copy_src->initialLayout;
pNext = SafePnextCopy(copy_src->pNext);
if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src->pQueueFamilyIndices, sizeof(uint32_t)*copy_src->queueFamilyIndexCount);
}
}
safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
image(in_struct->image),
viewType(in_struct->viewType),
format(in_struct->format),
components(in_struct->components),
subresourceRange(in_struct->subresourceRange)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo() :
sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO),
pNext(nullptr)
{}
safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
image = copy_src.image;
viewType = copy_src.viewType;
format = copy_src.format;
components = copy_src.components;
subresourceRange = copy_src.subresourceRange;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageViewCreateInfo& safe_VkImageViewCreateInfo::operator=(const safe_VkImageViewCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
image = copy_src.image;
viewType = copy_src.viewType;
format = copy_src.format;
components = copy_src.components;
subresourceRange = copy_src.subresourceRange;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageViewCreateInfo::~safe_VkImageViewCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageViewCreateInfo::initialize(const VkImageViewCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
image = in_struct->image;
viewType = in_struct->viewType;
format = in_struct->format;
components = in_struct->components;
subresourceRange = in_struct->subresourceRange;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageViewCreateInfo::initialize(const safe_VkImageViewCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
image = copy_src->image;
viewType = copy_src->viewType;
format = copy_src->format;
components = copy_src->components;
subresourceRange = copy_src->subresourceRange;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
codeSize(in_struct->codeSize),
pCode(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pCode) {
pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);
}
}
safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo() :
sType(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO),
pNext(nullptr),
pCode(nullptr)
{}
safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
codeSize = copy_src.codeSize;
pCode = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pCode) {
pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
memcpy((void *)pCode, (void *)copy_src.pCode, codeSize);
}
}
safe_VkShaderModuleCreateInfo& safe_VkShaderModuleCreateInfo::operator=(const safe_VkShaderModuleCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pCode)
delete[] reinterpret_cast<const uint8_t *>(pCode);
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
codeSize = copy_src.codeSize;
pCode = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pCode) {
pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
memcpy((void *)pCode, (void *)copy_src.pCode, codeSize);
}
return *this;
}
safe_VkShaderModuleCreateInfo::~safe_VkShaderModuleCreateInfo()
{
if (pCode)
delete[] reinterpret_cast<const uint8_t *>(pCode);
if (pNext)
FreePnextChain(pNext);
}
void safe_VkShaderModuleCreateInfo::initialize(const VkShaderModuleCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
codeSize = in_struct->codeSize;
pCode = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pCode) {
pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);
}
}
void safe_VkShaderModuleCreateInfo::initialize(const safe_VkShaderModuleCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
codeSize = copy_src->codeSize;
pCode = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pCode) {
pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
memcpy((void *)pCode, (void *)copy_src->pCode, codeSize);
}
}
safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
initialDataSize(in_struct->initialDataSize),
pInitialData(in_struct->pInitialData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO),
pNext(nullptr),
pInitialData(nullptr)
{}
safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
initialDataSize = copy_src.initialDataSize;
pInitialData = copy_src.pInitialData;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineCacheCreateInfo& safe_VkPipelineCacheCreateInfo::operator=(const safe_VkPipelineCacheCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
initialDataSize = copy_src.initialDataSize;
pInitialData = copy_src.pInitialData;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineCacheCreateInfo::~safe_VkPipelineCacheCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineCacheCreateInfo::initialize(const VkPipelineCacheCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
initialDataSize = in_struct->initialDataSize;
pInitialData = in_struct->pInitialData;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineCacheCreateInfo::initialize(const safe_VkPipelineCacheCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
initialDataSize = copy_src->initialDataSize;
pInitialData = copy_src->pInitialData;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSpecializationInfo::safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct) :
mapEntryCount(in_struct->mapEntryCount),
pMapEntries(nullptr),
dataSize(in_struct->dataSize),
pData(in_struct->pData)
{
if (in_struct->pMapEntries) {
pMapEntries = new VkSpecializationMapEntry[in_struct->mapEntryCount];
memcpy ((void *)pMapEntries, (void *)in_struct->pMapEntries, sizeof(VkSpecializationMapEntry)*in_struct->mapEntryCount);
}
}
safe_VkSpecializationInfo::safe_VkSpecializationInfo() :
pMapEntries(nullptr),
pData(nullptr)
{}
safe_VkSpecializationInfo::safe_VkSpecializationInfo(const safe_VkSpecializationInfo& copy_src)
{
mapEntryCount = copy_src.mapEntryCount;
pMapEntries = nullptr;
dataSize = copy_src.dataSize;
pData = copy_src.pData;
if (copy_src.pMapEntries) {
pMapEntries = new VkSpecializationMapEntry[copy_src.mapEntryCount];
memcpy ((void *)pMapEntries, (void *)copy_src.pMapEntries, sizeof(VkSpecializationMapEntry)*copy_src.mapEntryCount);
}
}
safe_VkSpecializationInfo& safe_VkSpecializationInfo::operator=(const safe_VkSpecializationInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pMapEntries)
delete[] pMapEntries;
mapEntryCount = copy_src.mapEntryCount;
pMapEntries = nullptr;
dataSize = copy_src.dataSize;
pData = copy_src.pData;
if (copy_src.pMapEntries) {
pMapEntries = new VkSpecializationMapEntry[copy_src.mapEntryCount];
memcpy ((void *)pMapEntries, (void *)copy_src.pMapEntries, sizeof(VkSpecializationMapEntry)*copy_src.mapEntryCount);
}
return *this;
}
safe_VkSpecializationInfo::~safe_VkSpecializationInfo()
{
if (pMapEntries)
delete[] pMapEntries;
}
void safe_VkSpecializationInfo::initialize(const VkSpecializationInfo* in_struct)
{
mapEntryCount = in_struct->mapEntryCount;
pMapEntries = nullptr;
dataSize = in_struct->dataSize;
pData = in_struct->pData;
if (in_struct->pMapEntries) {
pMapEntries = new VkSpecializationMapEntry[in_struct->mapEntryCount];
memcpy ((void *)pMapEntries, (void *)in_struct->pMapEntries, sizeof(VkSpecializationMapEntry)*in_struct->mapEntryCount);
}
}
void safe_VkSpecializationInfo::initialize(const safe_VkSpecializationInfo* copy_src)
{
mapEntryCount = copy_src->mapEntryCount;
pMapEntries = nullptr;
dataSize = copy_src->dataSize;
pData = copy_src->pData;
if (copy_src->pMapEntries) {
pMapEntries = new VkSpecializationMapEntry[copy_src->mapEntryCount];
memcpy ((void *)pMapEntries, (void *)copy_src->pMapEntries, sizeof(VkSpecializationMapEntry)*copy_src->mapEntryCount);
}
}
safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
stage(in_struct->stage),
module(in_struct->module),
pSpecializationInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
pName = SafeStringCopy(in_struct->pName);
if (in_struct->pSpecializationInfo)
pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
}
safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO),
pNext(nullptr),
pName(nullptr),
pSpecializationInfo(nullptr)
{}
safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
stage = copy_src.stage;
module = copy_src.module;
pSpecializationInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
pName = SafeStringCopy(copy_src.pName);
if (copy_src.pSpecializationInfo)
pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo);
}
safe_VkPipelineShaderStageCreateInfo& safe_VkPipelineShaderStageCreateInfo::operator=(const safe_VkPipelineShaderStageCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pName) delete [] pName;
if (pSpecializationInfo)
delete pSpecializationInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
stage = copy_src.stage;
module = copy_src.module;
pSpecializationInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
pName = SafeStringCopy(copy_src.pName);
if (copy_src.pSpecializationInfo)
pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo);
return *this;
}
safe_VkPipelineShaderStageCreateInfo::~safe_VkPipelineShaderStageCreateInfo()
{
if (pName) delete [] pName;
if (pSpecializationInfo)
delete pSpecializationInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineShaderStageCreateInfo::initialize(const VkPipelineShaderStageCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
stage = in_struct->stage;
module = in_struct->module;
pSpecializationInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
pName = SafeStringCopy(in_struct->pName);
if (in_struct->pSpecializationInfo)
pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
}
void safe_VkPipelineShaderStageCreateInfo::initialize(const safe_VkPipelineShaderStageCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
stage = copy_src->stage;
module = copy_src->module;
pSpecializationInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
pName = SafeStringCopy(copy_src->pName);
if (copy_src->pSpecializationInfo)
pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src->pSpecializationInfo);
}
safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
stage(&in_struct->stage),
layout(in_struct->layout),
basePipelineHandle(in_struct->basePipelineHandle),
basePipelineIndex(in_struct->basePipelineIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo() :
sType(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
stage.initialize(&copy_src.stage);
layout = copy_src.layout;
basePipelineHandle = copy_src.basePipelineHandle;
basePipelineIndex = copy_src.basePipelineIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkComputePipelineCreateInfo& safe_VkComputePipelineCreateInfo::operator=(const safe_VkComputePipelineCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
stage.initialize(&copy_src.stage);
layout = copy_src.layout;
basePipelineHandle = copy_src.basePipelineHandle;
basePipelineIndex = copy_src.basePipelineIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkComputePipelineCreateInfo::~safe_VkComputePipelineCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkComputePipelineCreateInfo::initialize(const VkComputePipelineCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
stage.initialize(&in_struct->stage);
layout = in_struct->layout;
basePipelineHandle = in_struct->basePipelineHandle;
basePipelineIndex = in_struct->basePipelineIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkComputePipelineCreateInfo::initialize(const safe_VkComputePipelineCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
stage.initialize(&copy_src->stage);
layout = copy_src->layout;
basePipelineHandle = copy_src->basePipelineHandle;
basePipelineIndex = copy_src->basePipelineIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
vertexBindingDescriptionCount(in_struct->vertexBindingDescriptionCount),
pVertexBindingDescriptions(nullptr),
vertexAttributeDescriptionCount(in_struct->vertexAttributeDescriptionCount),
pVertexAttributeDescriptions(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVertexBindingDescriptions) {
pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
memcpy ((void *)pVertexBindingDescriptions, (void *)in_struct->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*in_struct->vertexBindingDescriptionCount);
}
if (in_struct->pVertexAttributeDescriptions) {
pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
memcpy ((void *)pVertexAttributeDescriptions, (void *)in_struct->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*in_struct->vertexAttributeDescriptionCount);
}
}
safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
pNext(nullptr),
pVertexBindingDescriptions(nullptr),
pVertexAttributeDescriptions(nullptr)
{}
safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount;
pVertexBindingDescriptions = nullptr;
vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount;
pVertexAttributeDescriptions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVertexBindingDescriptions) {
pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount];
memcpy ((void *)pVertexBindingDescriptions, (void *)copy_src.pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*copy_src.vertexBindingDescriptionCount);
}
if (copy_src.pVertexAttributeDescriptions) {
pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount];
memcpy ((void *)pVertexAttributeDescriptions, (void *)copy_src.pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*copy_src.vertexAttributeDescriptionCount);
}
}
safe_VkPipelineVertexInputStateCreateInfo& safe_VkPipelineVertexInputStateCreateInfo::operator=(const safe_VkPipelineVertexInputStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pVertexBindingDescriptions)
delete[] pVertexBindingDescriptions;
if (pVertexAttributeDescriptions)
delete[] pVertexAttributeDescriptions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount;
pVertexBindingDescriptions = nullptr;
vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount;
pVertexAttributeDescriptions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVertexBindingDescriptions) {
pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount];
memcpy ((void *)pVertexBindingDescriptions, (void *)copy_src.pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*copy_src.vertexBindingDescriptionCount);
}
if (copy_src.pVertexAttributeDescriptions) {
pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount];
memcpy ((void *)pVertexAttributeDescriptions, (void *)copy_src.pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*copy_src.vertexAttributeDescriptionCount);
}
return *this;
}
safe_VkPipelineVertexInputStateCreateInfo::~safe_VkPipelineVertexInputStateCreateInfo()
{
if (pVertexBindingDescriptions)
delete[] pVertexBindingDescriptions;
if (pVertexAttributeDescriptions)
delete[] pVertexAttributeDescriptions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineVertexInputStateCreateInfo::initialize(const VkPipelineVertexInputStateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
vertexBindingDescriptionCount = in_struct->vertexBindingDescriptionCount;
pVertexBindingDescriptions = nullptr;
vertexAttributeDescriptionCount = in_struct->vertexAttributeDescriptionCount;
pVertexAttributeDescriptions = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVertexBindingDescriptions) {
pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
memcpy ((void *)pVertexBindingDescriptions, (void *)in_struct->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*in_struct->vertexBindingDescriptionCount);
}
if (in_struct->pVertexAttributeDescriptions) {
pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
memcpy ((void *)pVertexAttributeDescriptions, (void *)in_struct->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*in_struct->vertexAttributeDescriptionCount);
}
}
void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
vertexBindingDescriptionCount = copy_src->vertexBindingDescriptionCount;
pVertexBindingDescriptions = nullptr;
vertexAttributeDescriptionCount = copy_src->vertexAttributeDescriptionCount;
pVertexAttributeDescriptions = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pVertexBindingDescriptions) {
pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src->vertexBindingDescriptionCount];
memcpy ((void *)pVertexBindingDescriptions, (void *)copy_src->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*copy_src->vertexBindingDescriptionCount);
}
if (copy_src->pVertexAttributeDescriptions) {
pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src->vertexAttributeDescriptionCount];
memcpy ((void *)pVertexAttributeDescriptions, (void *)copy_src->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*copy_src->vertexAttributeDescriptionCount);
}
}
safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
topology(in_struct->topology),
primitiveRestartEnable(in_struct->primitiveRestartEnable)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
topology = copy_src.topology;
primitiveRestartEnable = copy_src.primitiveRestartEnable;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineInputAssemblyStateCreateInfo& safe_VkPipelineInputAssemblyStateCreateInfo::operator=(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
topology = copy_src.topology;
primitiveRestartEnable = copy_src.primitiveRestartEnable;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineInputAssemblyStateCreateInfo::~safe_VkPipelineInputAssemblyStateCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
topology = in_struct->topology;
primitiveRestartEnable = in_struct->primitiveRestartEnable;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
topology = copy_src->topology;
primitiveRestartEnable = copy_src->primitiveRestartEnable;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
patchControlPoints(in_struct->patchControlPoints)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
patchControlPoints = copy_src.patchControlPoints;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineTessellationStateCreateInfo& safe_VkPipelineTessellationStateCreateInfo::operator=(const safe_VkPipelineTessellationStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
patchControlPoints = copy_src.patchControlPoints;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineTessellationStateCreateInfo::~safe_VkPipelineTessellationStateCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineTessellationStateCreateInfo::initialize(const VkPipelineTessellationStateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
patchControlPoints = in_struct->patchControlPoints;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineTessellationStateCreateInfo::initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
patchControlPoints = copy_src->patchControlPoints;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors) :
sType(in_struct->sType),
flags(in_struct->flags),
viewportCount(in_struct->viewportCount),
pViewports(nullptr),
scissorCount(in_struct->scissorCount),
pScissors(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewports && !is_dynamic_viewports) {
pViewports = new VkViewport[in_struct->viewportCount];
memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);
}
else
pViewports = NULL;
if (in_struct->pScissors && !is_dynamic_scissors) {
pScissors = new VkRect2D[in_struct->scissorCount];
memcpy ((void *)pScissors, (void *)in_struct->pScissors, sizeof(VkRect2D)*in_struct->scissorCount);
}
else
pScissors = NULL;
}
safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO),
pNext(nullptr),
pViewports(nullptr),
pScissors(nullptr)
{}
safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
viewportCount = copy_src.viewportCount;
pViewports = nullptr;
scissorCount = copy_src.scissorCount;
pScissors = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewports) {
pViewports = new VkViewport[copy_src.viewportCount];
memcpy ((void *)pViewports, (void *)copy_src.pViewports, sizeof(VkViewport)*copy_src.viewportCount);
}
else
pViewports = NULL;
if (copy_src.pScissors) {
pScissors = new VkRect2D[copy_src.scissorCount];
memcpy ((void *)pScissors, (void *)copy_src.pScissors, sizeof(VkRect2D)*copy_src.scissorCount);
}
else
pScissors = NULL;
}
safe_VkPipelineViewportStateCreateInfo& safe_VkPipelineViewportStateCreateInfo::operator=(const safe_VkPipelineViewportStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pViewports)
delete[] pViewports;
if (pScissors)
delete[] pScissors;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
viewportCount = copy_src.viewportCount;
pViewports = nullptr;
scissorCount = copy_src.scissorCount;
pScissors = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewports) {
pViewports = new VkViewport[copy_src.viewportCount];
memcpy ((void *)pViewports, (void *)copy_src.pViewports, sizeof(VkViewport)*copy_src.viewportCount);
}
else
pViewports = NULL;
if (copy_src.pScissors) {
pScissors = new VkRect2D[copy_src.scissorCount];
memcpy ((void *)pScissors, (void *)copy_src.pScissors, sizeof(VkRect2D)*copy_src.scissorCount);
}
else
pScissors = NULL;
return *this;
}
safe_VkPipelineViewportStateCreateInfo::~safe_VkPipelineViewportStateCreateInfo()
{
if (pViewports)
delete[] pViewports;
if (pScissors)
delete[] pScissors;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineViewportStateCreateInfo::initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors)
{
sType = in_struct->sType;
flags = in_struct->flags;
viewportCount = in_struct->viewportCount;
pViewports = nullptr;
scissorCount = in_struct->scissorCount;
pScissors = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewports && !is_dynamic_viewports) {
pViewports = new VkViewport[in_struct->viewportCount];
memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);
}
else
pViewports = NULL;
if (in_struct->pScissors && !is_dynamic_scissors) {
pScissors = new VkRect2D[in_struct->scissorCount];
memcpy ((void *)pScissors, (void *)in_struct->pScissors, sizeof(VkRect2D)*in_struct->scissorCount);
}
else
pScissors = NULL;
}
void safe_VkPipelineViewportStateCreateInfo::initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
viewportCount = copy_src->viewportCount;
pViewports = nullptr;
scissorCount = copy_src->scissorCount;
pScissors = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pViewports) {
pViewports = new VkViewport[copy_src->viewportCount];
memcpy ((void *)pViewports, (void *)copy_src->pViewports, sizeof(VkViewport)*copy_src->viewportCount);
}
else
pViewports = NULL;
if (copy_src->pScissors) {
pScissors = new VkRect2D[copy_src->scissorCount];
memcpy ((void *)pScissors, (void *)copy_src->pScissors, sizeof(VkRect2D)*copy_src->scissorCount);
}
else
pScissors = NULL;
}
safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
depthClampEnable(in_struct->depthClampEnable),
rasterizerDiscardEnable(in_struct->rasterizerDiscardEnable),
polygonMode(in_struct->polygonMode),
cullMode(in_struct->cullMode),
frontFace(in_struct->frontFace),
depthBiasEnable(in_struct->depthBiasEnable),
depthBiasConstantFactor(in_struct->depthBiasConstantFactor),
depthBiasClamp(in_struct->depthBiasClamp),
depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor),
lineWidth(in_struct->lineWidth)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
depthClampEnable = copy_src.depthClampEnable;
rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable;
polygonMode = copy_src.polygonMode;
cullMode = copy_src.cullMode;
frontFace = copy_src.frontFace;
depthBiasEnable = copy_src.depthBiasEnable;
depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
depthBiasClamp = copy_src.depthBiasClamp;
depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
lineWidth = copy_src.lineWidth;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineRasterizationStateCreateInfo& safe_VkPipelineRasterizationStateCreateInfo::operator=(const safe_VkPipelineRasterizationStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
depthClampEnable = copy_src.depthClampEnable;
rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable;
polygonMode = copy_src.polygonMode;
cullMode = copy_src.cullMode;
frontFace = copy_src.frontFace;
depthBiasEnable = copy_src.depthBiasEnable;
depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
depthBiasClamp = copy_src.depthBiasClamp;
depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
lineWidth = copy_src.lineWidth;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineRasterizationStateCreateInfo::~safe_VkPipelineRasterizationStateCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineRasterizationStateCreateInfo::initialize(const VkPipelineRasterizationStateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
depthClampEnable = in_struct->depthClampEnable;
rasterizerDiscardEnable = in_struct->rasterizerDiscardEnable;
polygonMode = in_struct->polygonMode;
cullMode = in_struct->cullMode;
frontFace = in_struct->frontFace;
depthBiasEnable = in_struct->depthBiasEnable;
depthBiasConstantFactor = in_struct->depthBiasConstantFactor;
depthBiasClamp = in_struct->depthBiasClamp;
depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor;
lineWidth = in_struct->lineWidth;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
depthClampEnable = copy_src->depthClampEnable;
rasterizerDiscardEnable = copy_src->rasterizerDiscardEnable;
polygonMode = copy_src->polygonMode;
cullMode = copy_src->cullMode;
frontFace = copy_src->frontFace;
depthBiasEnable = copy_src->depthBiasEnable;
depthBiasConstantFactor = copy_src->depthBiasConstantFactor;
depthBiasClamp = copy_src->depthBiasClamp;
depthBiasSlopeFactor = copy_src->depthBiasSlopeFactor;
lineWidth = copy_src->lineWidth;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
rasterizationSamples(in_struct->rasterizationSamples),
sampleShadingEnable(in_struct->sampleShadingEnable),
minSampleShading(in_struct->minSampleShading),
pSampleMask(nullptr),
alphaToCoverageEnable(in_struct->alphaToCoverageEnable),
alphaToOneEnable(in_struct->alphaToOneEnable)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSampleMask) {
pSampleMask = new VkSampleMask(*in_struct->pSampleMask);
}
}
safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO),
pNext(nullptr),
pSampleMask(nullptr)
{}
safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
rasterizationSamples = copy_src.rasterizationSamples;
sampleShadingEnable = copy_src.sampleShadingEnable;
minSampleShading = copy_src.minSampleShading;
pSampleMask = nullptr;
alphaToCoverageEnable = copy_src.alphaToCoverageEnable;
alphaToOneEnable = copy_src.alphaToOneEnable;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSampleMask) {
pSampleMask = new VkSampleMask(*copy_src.pSampleMask);
}
}
safe_VkPipelineMultisampleStateCreateInfo& safe_VkPipelineMultisampleStateCreateInfo::operator=(const safe_VkPipelineMultisampleStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pSampleMask)
delete pSampleMask;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
rasterizationSamples = copy_src.rasterizationSamples;
sampleShadingEnable = copy_src.sampleShadingEnable;
minSampleShading = copy_src.minSampleShading;
pSampleMask = nullptr;
alphaToCoverageEnable = copy_src.alphaToCoverageEnable;
alphaToOneEnable = copy_src.alphaToOneEnable;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSampleMask) {
pSampleMask = new VkSampleMask(*copy_src.pSampleMask);
}
return *this;
}
safe_VkPipelineMultisampleStateCreateInfo::~safe_VkPipelineMultisampleStateCreateInfo()
{
if (pSampleMask)
delete pSampleMask;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineMultisampleStateCreateInfo::initialize(const VkPipelineMultisampleStateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
rasterizationSamples = in_struct->rasterizationSamples;
sampleShadingEnable = in_struct->sampleShadingEnable;
minSampleShading = in_struct->minSampleShading;
pSampleMask = nullptr;
alphaToCoverageEnable = in_struct->alphaToCoverageEnable;
alphaToOneEnable = in_struct->alphaToOneEnable;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSampleMask) {
pSampleMask = new VkSampleMask(*in_struct->pSampleMask);
}
}
void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
rasterizationSamples = copy_src->rasterizationSamples;
sampleShadingEnable = copy_src->sampleShadingEnable;
minSampleShading = copy_src->minSampleShading;
pSampleMask = nullptr;
alphaToCoverageEnable = copy_src->alphaToCoverageEnable;
alphaToOneEnable = copy_src->alphaToOneEnable;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pSampleMask) {
pSampleMask = new VkSampleMask(*copy_src->pSampleMask);
}
}
safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
depthTestEnable(in_struct->depthTestEnable),
depthWriteEnable(in_struct->depthWriteEnable),
depthCompareOp(in_struct->depthCompareOp),
depthBoundsTestEnable(in_struct->depthBoundsTestEnable),
stencilTestEnable(in_struct->stencilTestEnable),
front(in_struct->front),
back(in_struct->back),
minDepthBounds(in_struct->minDepthBounds),
maxDepthBounds(in_struct->maxDepthBounds)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
depthTestEnable = copy_src.depthTestEnable;
depthWriteEnable = copy_src.depthWriteEnable;
depthCompareOp = copy_src.depthCompareOp;
depthBoundsTestEnable = copy_src.depthBoundsTestEnable;
stencilTestEnable = copy_src.stencilTestEnable;
front = copy_src.front;
back = copy_src.back;
minDepthBounds = copy_src.minDepthBounds;
maxDepthBounds = copy_src.maxDepthBounds;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineDepthStencilStateCreateInfo& safe_VkPipelineDepthStencilStateCreateInfo::operator=(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
depthTestEnable = copy_src.depthTestEnable;
depthWriteEnable = copy_src.depthWriteEnable;
depthCompareOp = copy_src.depthCompareOp;
depthBoundsTestEnable = copy_src.depthBoundsTestEnable;
stencilTestEnable = copy_src.stencilTestEnable;
front = copy_src.front;
back = copy_src.back;
minDepthBounds = copy_src.minDepthBounds;
maxDepthBounds = copy_src.maxDepthBounds;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineDepthStencilStateCreateInfo::~safe_VkPipelineDepthStencilStateCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
depthTestEnable = in_struct->depthTestEnable;
depthWriteEnable = in_struct->depthWriteEnable;
depthCompareOp = in_struct->depthCompareOp;
depthBoundsTestEnable = in_struct->depthBoundsTestEnable;
stencilTestEnable = in_struct->stencilTestEnable;
front = in_struct->front;
back = in_struct->back;
minDepthBounds = in_struct->minDepthBounds;
maxDepthBounds = in_struct->maxDepthBounds;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
depthTestEnable = copy_src->depthTestEnable;
depthWriteEnable = copy_src->depthWriteEnable;
depthCompareOp = copy_src->depthCompareOp;
depthBoundsTestEnable = copy_src->depthBoundsTestEnable;
stencilTestEnable = copy_src->stencilTestEnable;
front = copy_src->front;
back = copy_src->back;
minDepthBounds = copy_src->minDepthBounds;
maxDepthBounds = copy_src->maxDepthBounds;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
logicOpEnable(in_struct->logicOpEnable),
logicOp(in_struct->logicOp),
attachmentCount(in_struct->attachmentCount),
pAttachments(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttachments) {
pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*in_struct->attachmentCount);
}
for (uint32_t i = 0; i < 4; ++i) {
blendConstants[i] = in_struct->blendConstants[i];
}
}
safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO),
pNext(nullptr),
pAttachments(nullptr)
{}
safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
logicOpEnable = copy_src.logicOpEnable;
logicOp = copy_src.logicOp;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttachments) {
pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount];
memcpy ((void *)pAttachments, (void *)copy_src.pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*copy_src.attachmentCount);
}
for (uint32_t i = 0; i < 4; ++i) {
blendConstants[i] = copy_src.blendConstants[i];
}
}
safe_VkPipelineColorBlendStateCreateInfo& safe_VkPipelineColorBlendStateCreateInfo::operator=(const safe_VkPipelineColorBlendStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pAttachments)
delete[] pAttachments;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
logicOpEnable = copy_src.logicOpEnable;
logicOp = copy_src.logicOp;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttachments) {
pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount];
memcpy ((void *)pAttachments, (void *)copy_src.pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*copy_src.attachmentCount);
}
for (uint32_t i = 0; i < 4; ++i) {
blendConstants[i] = copy_src.blendConstants[i];
}
return *this;
}
safe_VkPipelineColorBlendStateCreateInfo::~safe_VkPipelineColorBlendStateCreateInfo()
{
if (pAttachments)
delete[] pAttachments;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineColorBlendStateCreateInfo::initialize(const VkPipelineColorBlendStateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
logicOpEnable = in_struct->logicOpEnable;
logicOp = in_struct->logicOp;
attachmentCount = in_struct->attachmentCount;
pAttachments = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttachments) {
pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*in_struct->attachmentCount);
}
for (uint32_t i = 0; i < 4; ++i) {
blendConstants[i] = in_struct->blendConstants[i];
}
}
void safe_VkPipelineColorBlendStateCreateInfo::initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
logicOpEnable = copy_src->logicOpEnable;
logicOp = copy_src->logicOp;
attachmentCount = copy_src->attachmentCount;
pAttachments = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pAttachments) {
pAttachments = new VkPipelineColorBlendAttachmentState[copy_src->attachmentCount];
memcpy ((void *)pAttachments, (void *)copy_src->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*copy_src->attachmentCount);
}
for (uint32_t i = 0; i < 4; ++i) {
blendConstants[i] = copy_src->blendConstants[i];
}
}
safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
dynamicStateCount(in_struct->dynamicStateCount),
pDynamicStates(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDynamicStates) {
pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
memcpy ((void *)pDynamicStates, (void *)in_struct->pDynamicStates, sizeof(VkDynamicState)*in_struct->dynamicStateCount);
}
}
safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO),
pNext(nullptr),
pDynamicStates(nullptr)
{}
safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
dynamicStateCount = copy_src.dynamicStateCount;
pDynamicStates = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDynamicStates) {
pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount];
memcpy ((void *)pDynamicStates, (void *)copy_src.pDynamicStates, sizeof(VkDynamicState)*copy_src.dynamicStateCount);
}
}
safe_VkPipelineDynamicStateCreateInfo& safe_VkPipelineDynamicStateCreateInfo::operator=(const safe_VkPipelineDynamicStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pDynamicStates)
delete[] pDynamicStates;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
dynamicStateCount = copy_src.dynamicStateCount;
pDynamicStates = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDynamicStates) {
pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount];
memcpy ((void *)pDynamicStates, (void *)copy_src.pDynamicStates, sizeof(VkDynamicState)*copy_src.dynamicStateCount);
}
return *this;
}
safe_VkPipelineDynamicStateCreateInfo::~safe_VkPipelineDynamicStateCreateInfo()
{
if (pDynamicStates)
delete[] pDynamicStates;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineDynamicStateCreateInfo::initialize(const VkPipelineDynamicStateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
dynamicStateCount = in_struct->dynamicStateCount;
pDynamicStates = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDynamicStates) {
pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
memcpy ((void *)pDynamicStates, (void *)in_struct->pDynamicStates, sizeof(VkDynamicState)*in_struct->dynamicStateCount);
}
}
void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
dynamicStateCount = copy_src->dynamicStateCount;
pDynamicStates = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDynamicStates) {
pDynamicStates = new VkDynamicState[copy_src->dynamicStateCount];
memcpy ((void *)pDynamicStates, (void *)copy_src->pDynamicStates, sizeof(VkDynamicState)*copy_src->dynamicStateCount);
}
}
safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment) :
sType(in_struct->sType),
flags(in_struct->flags),
stageCount(in_struct->stageCount),
pStages(nullptr),
pVertexInputState(nullptr),
pInputAssemblyState(nullptr),
pTessellationState(nullptr),
pViewportState(nullptr),
pRasterizationState(nullptr),
pMultisampleState(nullptr),
pDepthStencilState(nullptr),
pColorBlendState(nullptr),
pDynamicState(nullptr),
layout(in_struct->layout),
renderPass(in_struct->renderPass),
subpass(in_struct->subpass),
basePipelineHandle(in_struct->basePipelineHandle),
basePipelineIndex(in_struct->basePipelineIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
if (stageCount && in_struct->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&in_struct->pStages[i]);
}
}
if (in_struct->pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
else
pVertexInputState = NULL;
if (in_struct->pInputAssemblyState)
pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);
else
pInputAssemblyState = NULL;
bool has_tessellation_stage = false;
if (stageCount && pStages)
for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
has_tessellation_stage = true;
if (in_struct->pTessellationState && has_tessellation_stage)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
else
pTessellationState = NULL; // original pTessellationState pointer ignored
bool has_rasterization = in_struct->pRasterizationState ? !in_struct->pRasterizationState->rasterizerDiscardEnable : false;
if (in_struct->pViewportState && has_rasterization) {
bool is_dynamic_viewports = false;
bool is_dynamic_scissors = false;
if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {
for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i)
if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT)
is_dynamic_viewports = true;
for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i)
if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR)
is_dynamic_scissors = true;
}
pViewportState = new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);
} else
pViewportState = NULL; // original pViewportState pointer ignored
if (in_struct->pRasterizationState)
pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
else
pRasterizationState = NULL;
if (in_struct->pMultisampleState && has_rasterization)
pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
else
pMultisampleState = NULL; // original pMultisampleState pointer ignored
// needs a tracked subpass state uses_depthstencil_attachment
if (in_struct->pDepthStencilState && has_rasterization && uses_depthstencil_attachment)
pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);
else
pDepthStencilState = NULL; // original pDepthStencilState pointer ignored
// needs a tracked subpass state usesColorAttachment
if (in_struct->pColorBlendState && has_rasterization && uses_color_attachment)
pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);
else
pColorBlendState = NULL; // original pColorBlendState pointer ignored
if (in_struct->pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
else
pDynamicState = NULL;
}
safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo() :
sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO),
pNext(nullptr),
pStages(nullptr),
pVertexInputState(nullptr),
pInputAssemblyState(nullptr),
pTessellationState(nullptr),
pViewportState(nullptr),
pRasterizationState(nullptr),
pMultisampleState(nullptr),
pDepthStencilState(nullptr),
pColorBlendState(nullptr),
pDynamicState(nullptr)
{}
safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
stageCount = copy_src.stageCount;
pStages = nullptr;
pVertexInputState = nullptr;
pInputAssemblyState = nullptr;
pTessellationState = nullptr;
pViewportState = nullptr;
pRasterizationState = nullptr;
pMultisampleState = nullptr;
pDepthStencilState = nullptr;
pColorBlendState = nullptr;
pDynamicState = nullptr;
layout = copy_src.layout;
renderPass = copy_src.renderPass;
subpass = copy_src.subpass;
basePipelineHandle = copy_src.basePipelineHandle;
basePipelineIndex = copy_src.basePipelineIndex;
pNext = SafePnextCopy(copy_src.pNext);
if (stageCount && copy_src.pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src.pStages[i]);
}
}
if (copy_src.pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
else
pVertexInputState = NULL;
if (copy_src.pInputAssemblyState)
pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src.pInputAssemblyState);
else
pInputAssemblyState = NULL;
bool has_tessellation_stage = false;
if (stageCount && pStages)
for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
has_tessellation_stage = true;
if (copy_src.pTessellationState && has_tessellation_stage)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
else
pTessellationState = NULL; // original pTessellationState pointer ignored
bool has_rasterization = copy_src.pRasterizationState ? !copy_src.pRasterizationState->rasterizerDiscardEnable : false;
if (copy_src.pViewportState && has_rasterization) {
pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState);
} else
pViewportState = NULL; // original pViewportState pointer ignored
if (copy_src.pRasterizationState)
pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src.pRasterizationState);
else
pRasterizationState = NULL;
if (copy_src.pMultisampleState && has_rasterization)
pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src.pMultisampleState);
else
pMultisampleState = NULL; // original pMultisampleState pointer ignored
if (copy_src.pDepthStencilState && has_rasterization)
pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src.pDepthStencilState);
else
pDepthStencilState = NULL; // original pDepthStencilState pointer ignored
if (copy_src.pColorBlendState && has_rasterization)
pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src.pColorBlendState);
else
pColorBlendState = NULL; // original pColorBlendState pointer ignored
if (copy_src.pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
else
pDynamicState = NULL;
}
safe_VkGraphicsPipelineCreateInfo& safe_VkGraphicsPipelineCreateInfo::operator=(const safe_VkGraphicsPipelineCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pStages)
delete[] pStages;
if (pVertexInputState)
delete pVertexInputState;
if (pInputAssemblyState)
delete pInputAssemblyState;
if (pTessellationState)
delete pTessellationState;
if (pViewportState)
delete pViewportState;
if (pRasterizationState)
delete pRasterizationState;
if (pMultisampleState)
delete pMultisampleState;
if (pDepthStencilState)
delete pDepthStencilState;
if (pColorBlendState)
delete pColorBlendState;
if (pDynamicState)
delete pDynamicState;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
stageCount = copy_src.stageCount;
pStages = nullptr;
pVertexInputState = nullptr;
pInputAssemblyState = nullptr;
pTessellationState = nullptr;
pViewportState = nullptr;
pRasterizationState = nullptr;
pMultisampleState = nullptr;
pDepthStencilState = nullptr;
pColorBlendState = nullptr;
pDynamicState = nullptr;
layout = copy_src.layout;
renderPass = copy_src.renderPass;
subpass = copy_src.subpass;
basePipelineHandle = copy_src.basePipelineHandle;
basePipelineIndex = copy_src.basePipelineIndex;
pNext = SafePnextCopy(copy_src.pNext);
if (stageCount && copy_src.pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src.pStages[i]);
}
}
if (copy_src.pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
else
pVertexInputState = NULL;
if (copy_src.pInputAssemblyState)
pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src.pInputAssemblyState);
else
pInputAssemblyState = NULL;
bool has_tessellation_stage = false;
if (stageCount && pStages)
for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
has_tessellation_stage = true;
if (copy_src.pTessellationState && has_tessellation_stage)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
else
pTessellationState = NULL; // original pTessellationState pointer ignored
bool has_rasterization = copy_src.pRasterizationState ? !copy_src.pRasterizationState->rasterizerDiscardEnable : false;
if (copy_src.pViewportState && has_rasterization) {
pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState);
} else
pViewportState = NULL; // original pViewportState pointer ignored
if (copy_src.pRasterizationState)
pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src.pRasterizationState);
else
pRasterizationState = NULL;
if (copy_src.pMultisampleState && has_rasterization)
pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src.pMultisampleState);
else
pMultisampleState = NULL; // original pMultisampleState pointer ignored
if (copy_src.pDepthStencilState && has_rasterization)
pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src.pDepthStencilState);
else
pDepthStencilState = NULL; // original pDepthStencilState pointer ignored
if (copy_src.pColorBlendState && has_rasterization)
pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src.pColorBlendState);
else
pColorBlendState = NULL; // original pColorBlendState pointer ignored
if (copy_src.pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
else
pDynamicState = NULL;
return *this;
}
safe_VkGraphicsPipelineCreateInfo::~safe_VkGraphicsPipelineCreateInfo()
{
if (pStages)
delete[] pStages;
if (pVertexInputState)
delete pVertexInputState;
if (pInputAssemblyState)
delete pInputAssemblyState;
if (pTessellationState)
delete pTessellationState;
if (pViewportState)
delete pViewportState;
if (pRasterizationState)
delete pRasterizationState;
if (pMultisampleState)
delete pMultisampleState;
if (pDepthStencilState)
delete pDepthStencilState;
if (pColorBlendState)
delete pColorBlendState;
if (pDynamicState)
delete pDynamicState;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment)
{
sType = in_struct->sType;
flags = in_struct->flags;
stageCount = in_struct->stageCount;
pStages = nullptr;
pVertexInputState = nullptr;
pInputAssemblyState = nullptr;
pTessellationState = nullptr;
pViewportState = nullptr;
pRasterizationState = nullptr;
pMultisampleState = nullptr;
pDepthStencilState = nullptr;
pColorBlendState = nullptr;
pDynamicState = nullptr;
layout = in_struct->layout;
renderPass = in_struct->renderPass;
subpass = in_struct->subpass;
basePipelineHandle = in_struct->basePipelineHandle;
basePipelineIndex = in_struct->basePipelineIndex;
pNext = SafePnextCopy(in_struct->pNext);
if (stageCount && in_struct->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&in_struct->pStages[i]);
}
}
if (in_struct->pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
else
pVertexInputState = NULL;
if (in_struct->pInputAssemblyState)
pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);
else
pInputAssemblyState = NULL;
bool has_tessellation_stage = false;
if (stageCount && pStages)
for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
has_tessellation_stage = true;
if (in_struct->pTessellationState && has_tessellation_stage)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
else
pTessellationState = NULL; // original pTessellationState pointer ignored
bool has_rasterization = in_struct->pRasterizationState ? !in_struct->pRasterizationState->rasterizerDiscardEnable : false;
if (in_struct->pViewportState && has_rasterization) {
bool is_dynamic_viewports = false;
bool is_dynamic_scissors = false;
if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {
for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i)
if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT)
is_dynamic_viewports = true;
for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i)
if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR)
is_dynamic_scissors = true;
}
pViewportState = new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);
} else
pViewportState = NULL; // original pViewportState pointer ignored
if (in_struct->pRasterizationState)
pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
else
pRasterizationState = NULL;
if (in_struct->pMultisampleState && has_rasterization)
pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
else
pMultisampleState = NULL; // original pMultisampleState pointer ignored
// needs a tracked subpass state uses_depthstencil_attachment
if (in_struct->pDepthStencilState && has_rasterization && uses_depthstencil_attachment)
pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);
else
pDepthStencilState = NULL; // original pDepthStencilState pointer ignored
// needs a tracked subpass state usesColorAttachment
if (in_struct->pColorBlendState && has_rasterization && uses_color_attachment)
pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);
else
pColorBlendState = NULL; // original pColorBlendState pointer ignored
if (in_struct->pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
else
pDynamicState = NULL;
}
void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipelineCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
stageCount = copy_src->stageCount;
pStages = nullptr;
pVertexInputState = nullptr;
pInputAssemblyState = nullptr;
pTessellationState = nullptr;
pViewportState = nullptr;
pRasterizationState = nullptr;
pMultisampleState = nullptr;
pDepthStencilState = nullptr;
pColorBlendState = nullptr;
pDynamicState = nullptr;
layout = copy_src->layout;
renderPass = copy_src->renderPass;
subpass = copy_src->subpass;
basePipelineHandle = copy_src->basePipelineHandle;
basePipelineIndex = copy_src->basePipelineIndex;
pNext = SafePnextCopy(copy_src->pNext);
if (stageCount && copy_src->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src->pStages[i]);
}
}
if (copy_src->pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src->pVertexInputState);
else
pVertexInputState = NULL;
if (copy_src->pInputAssemblyState)
pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src->pInputAssemblyState);
else
pInputAssemblyState = NULL;
bool has_tessellation_stage = false;
if (stageCount && pStages)
for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
has_tessellation_stage = true;
if (copy_src->pTessellationState && has_tessellation_stage)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src->pTessellationState);
else
pTessellationState = NULL; // original pTessellationState pointer ignored
bool has_rasterization = copy_src->pRasterizationState ? !copy_src->pRasterizationState->rasterizerDiscardEnable : false;
if (copy_src->pViewportState && has_rasterization) {
pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src->pViewportState);
} else
pViewportState = NULL; // original pViewportState pointer ignored
if (copy_src->pRasterizationState)
pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src->pRasterizationState);
else
pRasterizationState = NULL;
if (copy_src->pMultisampleState && has_rasterization)
pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src->pMultisampleState);
else
pMultisampleState = NULL; // original pMultisampleState pointer ignored
if (copy_src->pDepthStencilState && has_rasterization)
pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src->pDepthStencilState);
else
pDepthStencilState = NULL; // original pDepthStencilState pointer ignored
if (copy_src->pColorBlendState && has_rasterization)
pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src->pColorBlendState);
else
pColorBlendState = NULL; // original pColorBlendState pointer ignored
if (copy_src->pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src->pDynamicState);
else
pDynamicState = NULL;
}
safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
setLayoutCount(in_struct->setLayoutCount),
pSetLayouts(nullptr),
pushConstantRangeCount(in_struct->pushConstantRangeCount),
pPushConstantRanges(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (setLayoutCount && in_struct->pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
for (uint32_t i = 0; i < setLayoutCount; ++i) {
pSetLayouts[i] = in_struct->pSetLayouts[i];
}
}
if (in_struct->pPushConstantRanges) {
pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
memcpy ((void *)pPushConstantRanges, (void *)in_struct->pPushConstantRanges, sizeof(VkPushConstantRange)*in_struct->pushConstantRangeCount);
}
}
safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO),
pNext(nullptr),
pSetLayouts(nullptr),
pPushConstantRanges(nullptr)
{}
safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
setLayoutCount = copy_src.setLayoutCount;
pSetLayouts = nullptr;
pushConstantRangeCount = copy_src.pushConstantRangeCount;
pPushConstantRanges = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (setLayoutCount && copy_src.pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
for (uint32_t i = 0; i < setLayoutCount; ++i) {
pSetLayouts[i] = copy_src.pSetLayouts[i];
}
}
if (copy_src.pPushConstantRanges) {
pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount];
memcpy ((void *)pPushConstantRanges, (void *)copy_src.pPushConstantRanges, sizeof(VkPushConstantRange)*copy_src.pushConstantRangeCount);
}
}
safe_VkPipelineLayoutCreateInfo& safe_VkPipelineLayoutCreateInfo::operator=(const safe_VkPipelineLayoutCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pSetLayouts)
delete[] pSetLayouts;
if (pPushConstantRanges)
delete[] pPushConstantRanges;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
setLayoutCount = copy_src.setLayoutCount;
pSetLayouts = nullptr;
pushConstantRangeCount = copy_src.pushConstantRangeCount;
pPushConstantRanges = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (setLayoutCount && copy_src.pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
for (uint32_t i = 0; i < setLayoutCount; ++i) {
pSetLayouts[i] = copy_src.pSetLayouts[i];
}
}
if (copy_src.pPushConstantRanges) {
pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount];
memcpy ((void *)pPushConstantRanges, (void *)copy_src.pPushConstantRanges, sizeof(VkPushConstantRange)*copy_src.pushConstantRangeCount);
}
return *this;
}
safe_VkPipelineLayoutCreateInfo::~safe_VkPipelineLayoutCreateInfo()
{
if (pSetLayouts)
delete[] pSetLayouts;
if (pPushConstantRanges)
delete[] pPushConstantRanges;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineLayoutCreateInfo::initialize(const VkPipelineLayoutCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
setLayoutCount = in_struct->setLayoutCount;
pSetLayouts = nullptr;
pushConstantRangeCount = in_struct->pushConstantRangeCount;
pPushConstantRanges = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (setLayoutCount && in_struct->pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
for (uint32_t i = 0; i < setLayoutCount; ++i) {
pSetLayouts[i] = in_struct->pSetLayouts[i];
}
}
if (in_struct->pPushConstantRanges) {
pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
memcpy ((void *)pPushConstantRanges, (void *)in_struct->pPushConstantRanges, sizeof(VkPushConstantRange)*in_struct->pushConstantRangeCount);
}
}
void safe_VkPipelineLayoutCreateInfo::initialize(const safe_VkPipelineLayoutCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
setLayoutCount = copy_src->setLayoutCount;
pSetLayouts = nullptr;
pushConstantRangeCount = copy_src->pushConstantRangeCount;
pPushConstantRanges = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (setLayoutCount && copy_src->pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
for (uint32_t i = 0; i < setLayoutCount; ++i) {
pSetLayouts[i] = copy_src->pSetLayouts[i];
}
}
if (copy_src->pPushConstantRanges) {
pPushConstantRanges = new VkPushConstantRange[copy_src->pushConstantRangeCount];
memcpy ((void *)pPushConstantRanges, (void *)copy_src->pPushConstantRanges, sizeof(VkPushConstantRange)*copy_src->pushConstantRangeCount);
}
}
safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
magFilter(in_struct->magFilter),
minFilter(in_struct->minFilter),
mipmapMode(in_struct->mipmapMode),
addressModeU(in_struct->addressModeU),
addressModeV(in_struct->addressModeV),
addressModeW(in_struct->addressModeW),
mipLodBias(in_struct->mipLodBias),
anisotropyEnable(in_struct->anisotropyEnable),
maxAnisotropy(in_struct->maxAnisotropy),
compareEnable(in_struct->compareEnable),
compareOp(in_struct->compareOp),
minLod(in_struct->minLod),
maxLod(in_struct->maxLod),
borderColor(in_struct->borderColor),
unnormalizedCoordinates(in_struct->unnormalizedCoordinates)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo() :
sType(VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO),
pNext(nullptr)
{}
safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
magFilter = copy_src.magFilter;
minFilter = copy_src.minFilter;
mipmapMode = copy_src.mipmapMode;
addressModeU = copy_src.addressModeU;
addressModeV = copy_src.addressModeV;
addressModeW = copy_src.addressModeW;
mipLodBias = copy_src.mipLodBias;
anisotropyEnable = copy_src.anisotropyEnable;
maxAnisotropy = copy_src.maxAnisotropy;
compareEnable = copy_src.compareEnable;
compareOp = copy_src.compareOp;
minLod = copy_src.minLod;
maxLod = copy_src.maxLod;
borderColor = copy_src.borderColor;
unnormalizedCoordinates = copy_src.unnormalizedCoordinates;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSamplerCreateInfo& safe_VkSamplerCreateInfo::operator=(const safe_VkSamplerCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
magFilter = copy_src.magFilter;
minFilter = copy_src.minFilter;
mipmapMode = copy_src.mipmapMode;
addressModeU = copy_src.addressModeU;
addressModeV = copy_src.addressModeV;
addressModeW = copy_src.addressModeW;
mipLodBias = copy_src.mipLodBias;
anisotropyEnable = copy_src.anisotropyEnable;
maxAnisotropy = copy_src.maxAnisotropy;
compareEnable = copy_src.compareEnable;
compareOp = copy_src.compareOp;
minLod = copy_src.minLod;
maxLod = copy_src.maxLod;
borderColor = copy_src.borderColor;
unnormalizedCoordinates = copy_src.unnormalizedCoordinates;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSamplerCreateInfo::~safe_VkSamplerCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSamplerCreateInfo::initialize(const VkSamplerCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
magFilter = in_struct->magFilter;
minFilter = in_struct->minFilter;
mipmapMode = in_struct->mipmapMode;
addressModeU = in_struct->addressModeU;
addressModeV = in_struct->addressModeV;
addressModeW = in_struct->addressModeW;
mipLodBias = in_struct->mipLodBias;
anisotropyEnable = in_struct->anisotropyEnable;
maxAnisotropy = in_struct->maxAnisotropy;
compareEnable = in_struct->compareEnable;
compareOp = in_struct->compareOp;
minLod = in_struct->minLod;
maxLod = in_struct->maxLod;
borderColor = in_struct->borderColor;
unnormalizedCoordinates = in_struct->unnormalizedCoordinates;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSamplerCreateInfo::initialize(const safe_VkSamplerCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
magFilter = copy_src->magFilter;
minFilter = copy_src->minFilter;
mipmapMode = copy_src->mipmapMode;
addressModeU = copy_src->addressModeU;
addressModeV = copy_src->addressModeV;
addressModeW = copy_src->addressModeW;
mipLodBias = copy_src->mipLodBias;
anisotropyEnable = copy_src->anisotropyEnable;
maxAnisotropy = copy_src->maxAnisotropy;
compareEnable = copy_src->compareEnable;
compareOp = copy_src->compareOp;
minLod = copy_src->minLod;
maxLod = copy_src->maxLod;
borderColor = copy_src->borderColor;
unnormalizedCoordinates = copy_src->unnormalizedCoordinates;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct) :
sType(in_struct->sType),
srcSet(in_struct->srcSet),
srcBinding(in_struct->srcBinding),
srcArrayElement(in_struct->srcArrayElement),
dstSet(in_struct->dstSet),
dstBinding(in_struct->dstBinding),
dstArrayElement(in_struct->dstArrayElement),
descriptorCount(in_struct->descriptorCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet() :
sType(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET),
pNext(nullptr)
{}
safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& copy_src)
{
sType = copy_src.sType;
srcSet = copy_src.srcSet;
srcBinding = copy_src.srcBinding;
srcArrayElement = copy_src.srcArrayElement;
dstSet = copy_src.dstSet;
dstBinding = copy_src.dstBinding;
dstArrayElement = copy_src.dstArrayElement;
descriptorCount = copy_src.descriptorCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCopyDescriptorSet& safe_VkCopyDescriptorSet::operator=(const safe_VkCopyDescriptorSet& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcSet = copy_src.srcSet;
srcBinding = copy_src.srcBinding;
srcArrayElement = copy_src.srcArrayElement;
dstSet = copy_src.dstSet;
dstBinding = copy_src.dstBinding;
dstArrayElement = copy_src.dstArrayElement;
descriptorCount = copy_src.descriptorCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCopyDescriptorSet::~safe_VkCopyDescriptorSet()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyDescriptorSet::initialize(const VkCopyDescriptorSet* in_struct)
{
sType = in_struct->sType;
srcSet = in_struct->srcSet;
srcBinding = in_struct->srcBinding;
srcArrayElement = in_struct->srcArrayElement;
dstSet = in_struct->dstSet;
dstBinding = in_struct->dstBinding;
dstArrayElement = in_struct->dstArrayElement;
descriptorCount = in_struct->descriptorCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCopyDescriptorSet::initialize(const safe_VkCopyDescriptorSet* copy_src)
{
sType = copy_src->sType;
srcSet = copy_src->srcSet;
srcBinding = copy_src->srcBinding;
srcArrayElement = copy_src->srcArrayElement;
dstSet = copy_src->dstSet;
dstBinding = copy_src->dstBinding;
dstArrayElement = copy_src->dstArrayElement;
descriptorCount = copy_src->descriptorCount;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
maxSets(in_struct->maxSets),
poolSizeCount(in_struct->poolSizeCount),
pPoolSizes(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPoolSizes) {
pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount];
memcpy ((void *)pPoolSizes, (void *)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize)*in_struct->poolSizeCount);
}
}
safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO),
pNext(nullptr),
pPoolSizes(nullptr)
{}
safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
maxSets = copy_src.maxSets;
poolSizeCount = copy_src.poolSizeCount;
pPoolSizes = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPoolSizes) {
pPoolSizes = new VkDescriptorPoolSize[copy_src.poolSizeCount];
memcpy ((void *)pPoolSizes, (void *)copy_src.pPoolSizes, sizeof(VkDescriptorPoolSize)*copy_src.poolSizeCount);
}
}
safe_VkDescriptorPoolCreateInfo& safe_VkDescriptorPoolCreateInfo::operator=(const safe_VkDescriptorPoolCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pPoolSizes)
delete[] pPoolSizes;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
maxSets = copy_src.maxSets;
poolSizeCount = copy_src.poolSizeCount;
pPoolSizes = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPoolSizes) {
pPoolSizes = new VkDescriptorPoolSize[copy_src.poolSizeCount];
memcpy ((void *)pPoolSizes, (void *)copy_src.pPoolSizes, sizeof(VkDescriptorPoolSize)*copy_src.poolSizeCount);
}
return *this;
}
safe_VkDescriptorPoolCreateInfo::~safe_VkDescriptorPoolCreateInfo()
{
if (pPoolSizes)
delete[] pPoolSizes;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorPoolCreateInfo::initialize(const VkDescriptorPoolCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
maxSets = in_struct->maxSets;
poolSizeCount = in_struct->poolSizeCount;
pPoolSizes = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPoolSizes) {
pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount];
memcpy ((void *)pPoolSizes, (void *)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize)*in_struct->poolSizeCount);
}
}
void safe_VkDescriptorPoolCreateInfo::initialize(const safe_VkDescriptorPoolCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
maxSets = copy_src->maxSets;
poolSizeCount = copy_src->poolSizeCount;
pPoolSizes = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pPoolSizes) {
pPoolSizes = new VkDescriptorPoolSize[copy_src->poolSizeCount];
memcpy ((void *)pPoolSizes, (void *)copy_src->pPoolSizes, sizeof(VkDescriptorPoolSize)*copy_src->poolSizeCount);
}
}
safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct) :
sType(in_struct->sType),
descriptorPool(in_struct->descriptorPool),
descriptorSetCount(in_struct->descriptorSetCount),
pSetLayouts(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (descriptorSetCount && in_struct->pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
for (uint32_t i = 0; i < descriptorSetCount; ++i) {
pSetLayouts[i] = in_struct->pSetLayouts[i];
}
}
}
safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO),
pNext(nullptr),
pSetLayouts(nullptr)
{}
safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& copy_src)
{
sType = copy_src.sType;
descriptorPool = copy_src.descriptorPool;
descriptorSetCount = copy_src.descriptorSetCount;
pSetLayouts = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (descriptorSetCount && copy_src.pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
for (uint32_t i = 0; i < descriptorSetCount; ++i) {
pSetLayouts[i] = copy_src.pSetLayouts[i];
}
}
}
safe_VkDescriptorSetAllocateInfo& safe_VkDescriptorSetAllocateInfo::operator=(const safe_VkDescriptorSetAllocateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pSetLayouts)
delete[] pSetLayouts;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
descriptorPool = copy_src.descriptorPool;
descriptorSetCount = copy_src.descriptorSetCount;
pSetLayouts = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (descriptorSetCount && copy_src.pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
for (uint32_t i = 0; i < descriptorSetCount; ++i) {
pSetLayouts[i] = copy_src.pSetLayouts[i];
}
}
return *this;
}
safe_VkDescriptorSetAllocateInfo::~safe_VkDescriptorSetAllocateInfo()
{
if (pSetLayouts)
delete[] pSetLayouts;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorSetAllocateInfo::initialize(const VkDescriptorSetAllocateInfo* in_struct)
{
sType = in_struct->sType;
descriptorPool = in_struct->descriptorPool;
descriptorSetCount = in_struct->descriptorSetCount;
pSetLayouts = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (descriptorSetCount && in_struct->pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
for (uint32_t i = 0; i < descriptorSetCount; ++i) {
pSetLayouts[i] = in_struct->pSetLayouts[i];
}
}
}
void safe_VkDescriptorSetAllocateInfo::initialize(const safe_VkDescriptorSetAllocateInfo* copy_src)
{
sType = copy_src->sType;
descriptorPool = copy_src->descriptorPool;
descriptorSetCount = copy_src->descriptorSetCount;
pSetLayouts = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (descriptorSetCount && copy_src->pSetLayouts) {
pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
for (uint32_t i = 0; i < descriptorSetCount; ++i) {
pSetLayouts[i] = copy_src->pSetLayouts[i];
}
}
}
safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct) :
binding(in_struct->binding),
descriptorType(in_struct->descriptorType),
descriptorCount(in_struct->descriptorCount),
stageFlags(in_struct->stageFlags),
pImmutableSamplers(nullptr)
{
const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {
pImmutableSamplers = new VkSampler[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
}
}
}
safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding() :
pImmutableSamplers(nullptr)
{}
safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& copy_src)
{
binding = copy_src.binding;
descriptorType = copy_src.descriptorType;
descriptorCount = copy_src.descriptorCount;
stageFlags = copy_src.stageFlags;
pImmutableSamplers = nullptr;
const bool sampler_type = copy_src.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || copy_src.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
if (descriptorCount && copy_src.pImmutableSamplers && sampler_type) {
pImmutableSamplers = new VkSampler[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImmutableSamplers[i] = copy_src.pImmutableSamplers[i];
}
}
}
safe_VkDescriptorSetLayoutBinding& safe_VkDescriptorSetLayoutBinding::operator=(const safe_VkDescriptorSetLayoutBinding& copy_src)
{
if (&copy_src == this) return *this;
if (pImmutableSamplers)
delete[] pImmutableSamplers;
binding = copy_src.binding;
descriptorType = copy_src.descriptorType;
descriptorCount = copy_src.descriptorCount;
stageFlags = copy_src.stageFlags;
pImmutableSamplers = nullptr;
const bool sampler_type = copy_src.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || copy_src.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
if (descriptorCount && copy_src.pImmutableSamplers && sampler_type) {
pImmutableSamplers = new VkSampler[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImmutableSamplers[i] = copy_src.pImmutableSamplers[i];
}
}
return *this;
}
safe_VkDescriptorSetLayoutBinding::~safe_VkDescriptorSetLayoutBinding()
{
if (pImmutableSamplers)
delete[] pImmutableSamplers;
}
void safe_VkDescriptorSetLayoutBinding::initialize(const VkDescriptorSetLayoutBinding* in_struct)
{
binding = in_struct->binding;
descriptorType = in_struct->descriptorType;
descriptorCount = in_struct->descriptorCount;
stageFlags = in_struct->stageFlags;
pImmutableSamplers = nullptr;
const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {
pImmutableSamplers = new VkSampler[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
}
}
}
void safe_VkDescriptorSetLayoutBinding::initialize(const safe_VkDescriptorSetLayoutBinding* copy_src)
{
binding = copy_src->binding;
descriptorType = copy_src->descriptorType;
descriptorCount = copy_src->descriptorCount;
stageFlags = copy_src->stageFlags;
pImmutableSamplers = nullptr;
const bool sampler_type = copy_src->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || copy_src->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
if (descriptorCount && copy_src->pImmutableSamplers && sampler_type) {
pImmutableSamplers = new VkSampler[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImmutableSamplers[i] = copy_src->pImmutableSamplers[i];
}
}
}
safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
bindingCount(in_struct->bindingCount),
pBindings(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (bindingCount && in_struct->pBindings) {
pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
for (uint32_t i = 0; i < bindingCount; ++i) {
pBindings[i].initialize(&in_struct->pBindings[i]);
}
}
}
safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO),
pNext(nullptr),
pBindings(nullptr)
{}
safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
bindingCount = copy_src.bindingCount;
pBindings = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (bindingCount && copy_src.pBindings) {
pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
for (uint32_t i = 0; i < bindingCount; ++i) {
pBindings[i].initialize(&copy_src.pBindings[i]);
}
}
}
safe_VkDescriptorSetLayoutCreateInfo& safe_VkDescriptorSetLayoutCreateInfo::operator=(const safe_VkDescriptorSetLayoutCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pBindings)
delete[] pBindings;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
bindingCount = copy_src.bindingCount;
pBindings = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (bindingCount && copy_src.pBindings) {
pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
for (uint32_t i = 0; i < bindingCount; ++i) {
pBindings[i].initialize(&copy_src.pBindings[i]);
}
}
return *this;
}
safe_VkDescriptorSetLayoutCreateInfo::~safe_VkDescriptorSetLayoutCreateInfo()
{
if (pBindings)
delete[] pBindings;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorSetLayoutCreateInfo::initialize(const VkDescriptorSetLayoutCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
bindingCount = in_struct->bindingCount;
pBindings = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (bindingCount && in_struct->pBindings) {
pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
for (uint32_t i = 0; i < bindingCount; ++i) {
pBindings[i].initialize(&in_struct->pBindings[i]);
}
}
}
void safe_VkDescriptorSetLayoutCreateInfo::initialize(const safe_VkDescriptorSetLayoutCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
bindingCount = copy_src->bindingCount;
pBindings = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (bindingCount && copy_src->pBindings) {
pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
for (uint32_t i = 0; i < bindingCount; ++i) {
pBindings[i].initialize(&copy_src->pBindings[i]);
}
}
}
safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct) :
sType(in_struct->sType),
dstSet(in_struct->dstSet),
dstBinding(in_struct->dstBinding),
dstArrayElement(in_struct->dstArrayElement),
descriptorCount(in_struct->descriptorCount),
descriptorType(in_struct->descriptorType),
pImageInfo(nullptr),
pBufferInfo(nullptr),
pTexelBufferView(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
switch (descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
if (descriptorCount && in_struct->pImageInfo) {
pImageInfo = new VkDescriptorImageInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImageInfo[i] = in_struct->pImageInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
if (descriptorCount && in_struct->pBufferInfo) {
pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pBufferInfo[i] = in_struct->pBufferInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
if (descriptorCount && in_struct->pTexelBufferView) {
pTexelBufferView = new VkBufferView[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pTexelBufferView[i] = in_struct->pTexelBufferView[i];
}
}
break;
default:
break;
}
}
safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet() :
sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET),
pNext(nullptr),
pImageInfo(nullptr),
pBufferInfo(nullptr),
pTexelBufferView(nullptr)
{}
safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& copy_src)
{
sType = copy_src.sType;
dstSet = copy_src.dstSet;
dstBinding = copy_src.dstBinding;
dstArrayElement = copy_src.dstArrayElement;
descriptorCount = copy_src.descriptorCount;
descriptorType = copy_src.descriptorType;
pImageInfo = nullptr;
pBufferInfo = nullptr;
pTexelBufferView = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
switch (descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
if (descriptorCount && copy_src.pImageInfo) {
pImageInfo = new VkDescriptorImageInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImageInfo[i] = copy_src.pImageInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
if (descriptorCount && copy_src.pBufferInfo) {
pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pBufferInfo[i] = copy_src.pBufferInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
if (descriptorCount && copy_src.pTexelBufferView) {
pTexelBufferView = new VkBufferView[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pTexelBufferView[i] = copy_src.pTexelBufferView[i];
}
}
break;
default:
break;
}
}
safe_VkWriteDescriptorSet& safe_VkWriteDescriptorSet::operator=(const safe_VkWriteDescriptorSet& copy_src)
{
if (&copy_src == this) return *this;
if (pImageInfo)
delete[] pImageInfo;
if (pBufferInfo)
delete[] pBufferInfo;
if (pTexelBufferView)
delete[] pTexelBufferView;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
dstSet = copy_src.dstSet;
dstBinding = copy_src.dstBinding;
dstArrayElement = copy_src.dstArrayElement;
descriptorCount = copy_src.descriptorCount;
descriptorType = copy_src.descriptorType;
pImageInfo = nullptr;
pBufferInfo = nullptr;
pTexelBufferView = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
switch (descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
if (descriptorCount && copy_src.pImageInfo) {
pImageInfo = new VkDescriptorImageInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImageInfo[i] = copy_src.pImageInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
if (descriptorCount && copy_src.pBufferInfo) {
pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pBufferInfo[i] = copy_src.pBufferInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
if (descriptorCount && copy_src.pTexelBufferView) {
pTexelBufferView = new VkBufferView[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pTexelBufferView[i] = copy_src.pTexelBufferView[i];
}
}
break;
default:
break;
}
return *this;
}
safe_VkWriteDescriptorSet::~safe_VkWriteDescriptorSet()
{
if (pImageInfo)
delete[] pImageInfo;
if (pBufferInfo)
delete[] pBufferInfo;
if (pTexelBufferView)
delete[] pTexelBufferView;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct)
{
sType = in_struct->sType;
dstSet = in_struct->dstSet;
dstBinding = in_struct->dstBinding;
dstArrayElement = in_struct->dstArrayElement;
descriptorCount = in_struct->descriptorCount;
descriptorType = in_struct->descriptorType;
pImageInfo = nullptr;
pBufferInfo = nullptr;
pTexelBufferView = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
switch (descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
if (descriptorCount && in_struct->pImageInfo) {
pImageInfo = new VkDescriptorImageInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImageInfo[i] = in_struct->pImageInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
if (descriptorCount && in_struct->pBufferInfo) {
pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pBufferInfo[i] = in_struct->pBufferInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
if (descriptorCount && in_struct->pTexelBufferView) {
pTexelBufferView = new VkBufferView[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pTexelBufferView[i] = in_struct->pTexelBufferView[i];
}
}
break;
default:
break;
}
}
void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* copy_src)
{
sType = copy_src->sType;
dstSet = copy_src->dstSet;
dstBinding = copy_src->dstBinding;
dstArrayElement = copy_src->dstArrayElement;
descriptorCount = copy_src->descriptorCount;
descriptorType = copy_src->descriptorType;
pImageInfo = nullptr;
pBufferInfo = nullptr;
pTexelBufferView = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
switch (descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
if (descriptorCount && copy_src->pImageInfo) {
pImageInfo = new VkDescriptorImageInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pImageInfo[i] = copy_src->pImageInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
if (descriptorCount && copy_src->pBufferInfo) {
pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pBufferInfo[i] = copy_src->pBufferInfo[i];
}
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
if (descriptorCount && copy_src->pTexelBufferView) {
pTexelBufferView = new VkBufferView[descriptorCount];
for (uint32_t i = 0; i < descriptorCount; ++i) {
pTexelBufferView[i] = copy_src->pTexelBufferView[i];
}
}
break;
default:
break;
}
}
safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
renderPass(in_struct->renderPass),
attachmentCount(in_struct->attachmentCount),
pAttachments(nullptr),
width(in_struct->width),
height(in_struct->height),
layers(in_struct->layers)
{
pNext = SafePnextCopy(in_struct->pNext);
if (attachmentCount && in_struct->pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = in_struct->pAttachments[i];
}
}
}
safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo() :
sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO),
pNext(nullptr),
pAttachments(nullptr)
{}
safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
renderPass = copy_src.renderPass;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
width = copy_src.width;
height = copy_src.height;
layers = copy_src.layers;
pNext = SafePnextCopy(copy_src.pNext);
if (attachmentCount && copy_src.pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = copy_src.pAttachments[i];
}
}
}
safe_VkFramebufferCreateInfo& safe_VkFramebufferCreateInfo::operator=(const safe_VkFramebufferCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pAttachments)
delete[] pAttachments;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
renderPass = copy_src.renderPass;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
width = copy_src.width;
height = copy_src.height;
layers = copy_src.layers;
pNext = SafePnextCopy(copy_src.pNext);
if (attachmentCount && copy_src.pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = copy_src.pAttachments[i];
}
}
return *this;
}
safe_VkFramebufferCreateInfo::~safe_VkFramebufferCreateInfo()
{
if (pAttachments)
delete[] pAttachments;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFramebufferCreateInfo::initialize(const VkFramebufferCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
renderPass = in_struct->renderPass;
attachmentCount = in_struct->attachmentCount;
pAttachments = nullptr;
width = in_struct->width;
height = in_struct->height;
layers = in_struct->layers;
pNext = SafePnextCopy(in_struct->pNext);
if (attachmentCount && in_struct->pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = in_struct->pAttachments[i];
}
}
}
void safe_VkFramebufferCreateInfo::initialize(const safe_VkFramebufferCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
renderPass = copy_src->renderPass;
attachmentCount = copy_src->attachmentCount;
pAttachments = nullptr;
width = copy_src->width;
height = copy_src->height;
layers = copy_src->layers;
pNext = SafePnextCopy(copy_src->pNext);
if (attachmentCount && copy_src->pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = copy_src->pAttachments[i];
}
}
}
safe_VkSubpassDescription::safe_VkSubpassDescription(const VkSubpassDescription* in_struct) :
flags(in_struct->flags),
pipelineBindPoint(in_struct->pipelineBindPoint),
inputAttachmentCount(in_struct->inputAttachmentCount),
pInputAttachments(nullptr),
colorAttachmentCount(in_struct->colorAttachmentCount),
pColorAttachments(nullptr),
pResolveAttachments(nullptr),
pDepthStencilAttachment(nullptr),
preserveAttachmentCount(in_struct->preserveAttachmentCount),
pPreserveAttachments(nullptr)
{
if (in_struct->pInputAttachments) {
pInputAttachments = new VkAttachmentReference[in_struct->inputAttachmentCount];
memcpy ((void *)pInputAttachments, (void *)in_struct->pInputAttachments, sizeof(VkAttachmentReference)*in_struct->inputAttachmentCount);
}
if (in_struct->pColorAttachments) {
pColorAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
memcpy ((void *)pColorAttachments, (void *)in_struct->pColorAttachments, sizeof(VkAttachmentReference)*in_struct->colorAttachmentCount);
}
if (in_struct->pResolveAttachments) {
pResolveAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
memcpy ((void *)pResolveAttachments, (void *)in_struct->pResolveAttachments, sizeof(VkAttachmentReference)*in_struct->colorAttachmentCount);
}
if (in_struct->pDepthStencilAttachment) {
pDepthStencilAttachment = new VkAttachmentReference(*in_struct->pDepthStencilAttachment);
}
if (in_struct->pPreserveAttachments) {
pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)in_struct->pPreserveAttachments, sizeof(uint32_t)*in_struct->preserveAttachmentCount);
}
}
safe_VkSubpassDescription::safe_VkSubpassDescription() :
pInputAttachments(nullptr),
pColorAttachments(nullptr),
pResolveAttachments(nullptr),
pDepthStencilAttachment(nullptr),
pPreserveAttachments(nullptr)
{}
safe_VkSubpassDescription::safe_VkSubpassDescription(const safe_VkSubpassDescription& copy_src)
{
flags = copy_src.flags;
pipelineBindPoint = copy_src.pipelineBindPoint;
inputAttachmentCount = copy_src.inputAttachmentCount;
pInputAttachments = nullptr;
colorAttachmentCount = copy_src.colorAttachmentCount;
pColorAttachments = nullptr;
pResolveAttachments = nullptr;
pDepthStencilAttachment = nullptr;
preserveAttachmentCount = copy_src.preserveAttachmentCount;
pPreserveAttachments = nullptr;
if (copy_src.pInputAttachments) {
pInputAttachments = new VkAttachmentReference[copy_src.inputAttachmentCount];
memcpy ((void *)pInputAttachments, (void *)copy_src.pInputAttachments, sizeof(VkAttachmentReference)*copy_src.inputAttachmentCount);
}
if (copy_src.pColorAttachments) {
pColorAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount];
memcpy ((void *)pColorAttachments, (void *)copy_src.pColorAttachments, sizeof(VkAttachmentReference)*copy_src.colorAttachmentCount);
}
if (copy_src.pResolveAttachments) {
pResolveAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount];
memcpy ((void *)pResolveAttachments, (void *)copy_src.pResolveAttachments, sizeof(VkAttachmentReference)*copy_src.colorAttachmentCount);
}
if (copy_src.pDepthStencilAttachment) {
pDepthStencilAttachment = new VkAttachmentReference(*copy_src.pDepthStencilAttachment);
}
if (copy_src.pPreserveAttachments) {
pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)copy_src.pPreserveAttachments, sizeof(uint32_t)*copy_src.preserveAttachmentCount);
}
}
safe_VkSubpassDescription& safe_VkSubpassDescription::operator=(const safe_VkSubpassDescription& copy_src)
{
if (&copy_src == this) return *this;
if (pInputAttachments)
delete[] pInputAttachments;
if (pColorAttachments)
delete[] pColorAttachments;
if (pResolveAttachments)
delete[] pResolveAttachments;
if (pDepthStencilAttachment)
delete pDepthStencilAttachment;
if (pPreserveAttachments)
delete[] pPreserveAttachments;
flags = copy_src.flags;
pipelineBindPoint = copy_src.pipelineBindPoint;
inputAttachmentCount = copy_src.inputAttachmentCount;
pInputAttachments = nullptr;
colorAttachmentCount = copy_src.colorAttachmentCount;
pColorAttachments = nullptr;
pResolveAttachments = nullptr;
pDepthStencilAttachment = nullptr;
preserveAttachmentCount = copy_src.preserveAttachmentCount;
pPreserveAttachments = nullptr;
if (copy_src.pInputAttachments) {
pInputAttachments = new VkAttachmentReference[copy_src.inputAttachmentCount];
memcpy ((void *)pInputAttachments, (void *)copy_src.pInputAttachments, sizeof(VkAttachmentReference)*copy_src.inputAttachmentCount);
}
if (copy_src.pColorAttachments) {
pColorAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount];
memcpy ((void *)pColorAttachments, (void *)copy_src.pColorAttachments, sizeof(VkAttachmentReference)*copy_src.colorAttachmentCount);
}
if (copy_src.pResolveAttachments) {
pResolveAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount];
memcpy ((void *)pResolveAttachments, (void *)copy_src.pResolveAttachments, sizeof(VkAttachmentReference)*copy_src.colorAttachmentCount);
}
if (copy_src.pDepthStencilAttachment) {
pDepthStencilAttachment = new VkAttachmentReference(*copy_src.pDepthStencilAttachment);
}
if (copy_src.pPreserveAttachments) {
pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)copy_src.pPreserveAttachments, sizeof(uint32_t)*copy_src.preserveAttachmentCount);
}
return *this;
}
safe_VkSubpassDescription::~safe_VkSubpassDescription()
{
if (pInputAttachments)
delete[] pInputAttachments;
if (pColorAttachments)
delete[] pColorAttachments;
if (pResolveAttachments)
delete[] pResolveAttachments;
if (pDepthStencilAttachment)
delete pDepthStencilAttachment;
if (pPreserveAttachments)
delete[] pPreserveAttachments;
}
void safe_VkSubpassDescription::initialize(const VkSubpassDescription* in_struct)
{
flags = in_struct->flags;
pipelineBindPoint = in_struct->pipelineBindPoint;
inputAttachmentCount = in_struct->inputAttachmentCount;
pInputAttachments = nullptr;
colorAttachmentCount = in_struct->colorAttachmentCount;
pColorAttachments = nullptr;
pResolveAttachments = nullptr;
pDepthStencilAttachment = nullptr;
preserveAttachmentCount = in_struct->preserveAttachmentCount;
pPreserveAttachments = nullptr;
if (in_struct->pInputAttachments) {
pInputAttachments = new VkAttachmentReference[in_struct->inputAttachmentCount];
memcpy ((void *)pInputAttachments, (void *)in_struct->pInputAttachments, sizeof(VkAttachmentReference)*in_struct->inputAttachmentCount);
}
if (in_struct->pColorAttachments) {
pColorAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
memcpy ((void *)pColorAttachments, (void *)in_struct->pColorAttachments, sizeof(VkAttachmentReference)*in_struct->colorAttachmentCount);
}
if (in_struct->pResolveAttachments) {
pResolveAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
memcpy ((void *)pResolveAttachments, (void *)in_struct->pResolveAttachments, sizeof(VkAttachmentReference)*in_struct->colorAttachmentCount);
}
if (in_struct->pDepthStencilAttachment) {
pDepthStencilAttachment = new VkAttachmentReference(*in_struct->pDepthStencilAttachment);
}
if (in_struct->pPreserveAttachments) {
pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)in_struct->pPreserveAttachments, sizeof(uint32_t)*in_struct->preserveAttachmentCount);
}
}
void safe_VkSubpassDescription::initialize(const safe_VkSubpassDescription* copy_src)
{
flags = copy_src->flags;
pipelineBindPoint = copy_src->pipelineBindPoint;
inputAttachmentCount = copy_src->inputAttachmentCount;
pInputAttachments = nullptr;
colorAttachmentCount = copy_src->colorAttachmentCount;
pColorAttachments = nullptr;
pResolveAttachments = nullptr;
pDepthStencilAttachment = nullptr;
preserveAttachmentCount = copy_src->preserveAttachmentCount;
pPreserveAttachments = nullptr;
if (copy_src->pInputAttachments) {
pInputAttachments = new VkAttachmentReference[copy_src->inputAttachmentCount];
memcpy ((void *)pInputAttachments, (void *)copy_src->pInputAttachments, sizeof(VkAttachmentReference)*copy_src->inputAttachmentCount);
}
if (copy_src->pColorAttachments) {
pColorAttachments = new VkAttachmentReference[copy_src->colorAttachmentCount];
memcpy ((void *)pColorAttachments, (void *)copy_src->pColorAttachments, sizeof(VkAttachmentReference)*copy_src->colorAttachmentCount);
}
if (copy_src->pResolveAttachments) {
pResolveAttachments = new VkAttachmentReference[copy_src->colorAttachmentCount];
memcpy ((void *)pResolveAttachments, (void *)copy_src->pResolveAttachments, sizeof(VkAttachmentReference)*copy_src->colorAttachmentCount);
}
if (copy_src->pDepthStencilAttachment) {
pDepthStencilAttachment = new VkAttachmentReference(*copy_src->pDepthStencilAttachment);
}
if (copy_src->pPreserveAttachments) {
pPreserveAttachments = new uint32_t[copy_src->preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)copy_src->pPreserveAttachments, sizeof(uint32_t)*copy_src->preserveAttachmentCount);
}
}
safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
attachmentCount(in_struct->attachmentCount),
pAttachments(nullptr),
subpassCount(in_struct->subpassCount),
pSubpasses(nullptr),
dependencyCount(in_struct->dependencyCount),
pDependencies(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttachments) {
pAttachments = new VkAttachmentDescription[in_struct->attachmentCount];
memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkAttachmentDescription)*in_struct->attachmentCount);
}
if (subpassCount && in_struct->pSubpasses) {
pSubpasses = new safe_VkSubpassDescription[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
}
}
if (in_struct->pDependencies) {
pDependencies = new VkSubpassDependency[in_struct->dependencyCount];
memcpy ((void *)pDependencies, (void *)in_struct->pDependencies, sizeof(VkSubpassDependency)*in_struct->dependencyCount);
}
}
safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO),
pNext(nullptr),
pAttachments(nullptr),
pSubpasses(nullptr),
pDependencies(nullptr)
{}
safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
subpassCount = copy_src.subpassCount;
pSubpasses = nullptr;
dependencyCount = copy_src.dependencyCount;
pDependencies = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttachments) {
pAttachments = new VkAttachmentDescription[copy_src.attachmentCount];
memcpy ((void *)pAttachments, (void *)copy_src.pAttachments, sizeof(VkAttachmentDescription)*copy_src.attachmentCount);
}
if (subpassCount && copy_src.pSubpasses) {
pSubpasses = new safe_VkSubpassDescription[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
}
}
if (copy_src.pDependencies) {
pDependencies = new VkSubpassDependency[copy_src.dependencyCount];
memcpy ((void *)pDependencies, (void *)copy_src.pDependencies, sizeof(VkSubpassDependency)*copy_src.dependencyCount);
}
}
safe_VkRenderPassCreateInfo& safe_VkRenderPassCreateInfo::operator=(const safe_VkRenderPassCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pAttachments)
delete[] pAttachments;
if (pSubpasses)
delete[] pSubpasses;
if (pDependencies)
delete[] pDependencies;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
subpassCount = copy_src.subpassCount;
pSubpasses = nullptr;
dependencyCount = copy_src.dependencyCount;
pDependencies = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttachments) {
pAttachments = new VkAttachmentDescription[copy_src.attachmentCount];
memcpy ((void *)pAttachments, (void *)copy_src.pAttachments, sizeof(VkAttachmentDescription)*copy_src.attachmentCount);
}
if (subpassCount && copy_src.pSubpasses) {
pSubpasses = new safe_VkSubpassDescription[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
}
}
if (copy_src.pDependencies) {
pDependencies = new VkSubpassDependency[copy_src.dependencyCount];
memcpy ((void *)pDependencies, (void *)copy_src.pDependencies, sizeof(VkSubpassDependency)*copy_src.dependencyCount);
}
return *this;
}
safe_VkRenderPassCreateInfo::~safe_VkRenderPassCreateInfo()
{
if (pAttachments)
delete[] pAttachments;
if (pSubpasses)
delete[] pSubpasses;
if (pDependencies)
delete[] pDependencies;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassCreateInfo::initialize(const VkRenderPassCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
attachmentCount = in_struct->attachmentCount;
pAttachments = nullptr;
subpassCount = in_struct->subpassCount;
pSubpasses = nullptr;
dependencyCount = in_struct->dependencyCount;
pDependencies = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttachments) {
pAttachments = new VkAttachmentDescription[in_struct->attachmentCount];
memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkAttachmentDescription)*in_struct->attachmentCount);
}
if (subpassCount && in_struct->pSubpasses) {
pSubpasses = new safe_VkSubpassDescription[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
}
}
if (in_struct->pDependencies) {
pDependencies = new VkSubpassDependency[in_struct->dependencyCount];
memcpy ((void *)pDependencies, (void *)in_struct->pDependencies, sizeof(VkSubpassDependency)*in_struct->dependencyCount);
}
}
void safe_VkRenderPassCreateInfo::initialize(const safe_VkRenderPassCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
attachmentCount = copy_src->attachmentCount;
pAttachments = nullptr;
subpassCount = copy_src->subpassCount;
pSubpasses = nullptr;
dependencyCount = copy_src->dependencyCount;
pDependencies = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pAttachments) {
pAttachments = new VkAttachmentDescription[copy_src->attachmentCount];
memcpy ((void *)pAttachments, (void *)copy_src->pAttachments, sizeof(VkAttachmentDescription)*copy_src->attachmentCount);
}
if (subpassCount && copy_src->pSubpasses) {
pSubpasses = new safe_VkSubpassDescription[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&copy_src->pSubpasses[i]);
}
}
if (copy_src->pDependencies) {
pDependencies = new VkSubpassDependency[copy_src->dependencyCount];
memcpy ((void *)pDependencies, (void *)copy_src->pDependencies, sizeof(VkSubpassDependency)*copy_src->dependencyCount);
}
}
safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
queueFamilyIndex(in_struct->queueFamilyIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo() :
sType(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO),
pNext(nullptr)
{}
safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
queueFamilyIndex = copy_src.queueFamilyIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCommandPoolCreateInfo& safe_VkCommandPoolCreateInfo::operator=(const safe_VkCommandPoolCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
queueFamilyIndex = copy_src.queueFamilyIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCommandPoolCreateInfo::~safe_VkCommandPoolCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCommandPoolCreateInfo::initialize(const VkCommandPoolCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
queueFamilyIndex = in_struct->queueFamilyIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCommandPoolCreateInfo::initialize(const safe_VkCommandPoolCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
queueFamilyIndex = copy_src->queueFamilyIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct) :
sType(in_struct->sType),
commandPool(in_struct->commandPool),
level(in_struct->level),
commandBufferCount(in_struct->commandBufferCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo() :
sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO),
pNext(nullptr)
{}
safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& copy_src)
{
sType = copy_src.sType;
commandPool = copy_src.commandPool;
level = copy_src.level;
commandBufferCount = copy_src.commandBufferCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCommandBufferAllocateInfo& safe_VkCommandBufferAllocateInfo::operator=(const safe_VkCommandBufferAllocateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
commandPool = copy_src.commandPool;
level = copy_src.level;
commandBufferCount = copy_src.commandBufferCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCommandBufferAllocateInfo::~safe_VkCommandBufferAllocateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCommandBufferAllocateInfo::initialize(const VkCommandBufferAllocateInfo* in_struct)
{
sType = in_struct->sType;
commandPool = in_struct->commandPool;
level = in_struct->level;
commandBufferCount = in_struct->commandBufferCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCommandBufferAllocateInfo::initialize(const safe_VkCommandBufferAllocateInfo* copy_src)
{
sType = copy_src->sType;
commandPool = copy_src->commandPool;
level = copy_src->level;
commandBufferCount = copy_src->commandBufferCount;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct) :
sType(in_struct->sType),
renderPass(in_struct->renderPass),
subpass(in_struct->subpass),
framebuffer(in_struct->framebuffer),
occlusionQueryEnable(in_struct->occlusionQueryEnable),
queryFlags(in_struct->queryFlags),
pipelineStatistics(in_struct->pipelineStatistics)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo() :
sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO),
pNext(nullptr)
{}
safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& copy_src)
{
sType = copy_src.sType;
renderPass = copy_src.renderPass;
subpass = copy_src.subpass;
framebuffer = copy_src.framebuffer;
occlusionQueryEnable = copy_src.occlusionQueryEnable;
queryFlags = copy_src.queryFlags;
pipelineStatistics = copy_src.pipelineStatistics;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCommandBufferInheritanceInfo& safe_VkCommandBufferInheritanceInfo::operator=(const safe_VkCommandBufferInheritanceInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
renderPass = copy_src.renderPass;
subpass = copy_src.subpass;
framebuffer = copy_src.framebuffer;
occlusionQueryEnable = copy_src.occlusionQueryEnable;
queryFlags = copy_src.queryFlags;
pipelineStatistics = copy_src.pipelineStatistics;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCommandBufferInheritanceInfo::~safe_VkCommandBufferInheritanceInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCommandBufferInheritanceInfo::initialize(const VkCommandBufferInheritanceInfo* in_struct)
{
sType = in_struct->sType;
renderPass = in_struct->renderPass;
subpass = in_struct->subpass;
framebuffer = in_struct->framebuffer;
occlusionQueryEnable = in_struct->occlusionQueryEnable;
queryFlags = in_struct->queryFlags;
pipelineStatistics = in_struct->pipelineStatistics;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCommandBufferInheritanceInfo::initialize(const safe_VkCommandBufferInheritanceInfo* copy_src)
{
sType = copy_src->sType;
renderPass = copy_src->renderPass;
subpass = copy_src->subpass;
framebuffer = copy_src->framebuffer;
occlusionQueryEnable = copy_src->occlusionQueryEnable;
queryFlags = copy_src->queryFlags;
pipelineStatistics = copy_src->pipelineStatistics;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
pInheritanceInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pInheritanceInfo)
pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
}
safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo() :
sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO),
pNext(nullptr),
pInheritanceInfo(nullptr)
{}
safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pInheritanceInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pInheritanceInfo)
pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src.pInheritanceInfo);
}
safe_VkCommandBufferBeginInfo& safe_VkCommandBufferBeginInfo::operator=(const safe_VkCommandBufferBeginInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pInheritanceInfo)
delete pInheritanceInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pInheritanceInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pInheritanceInfo)
pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src.pInheritanceInfo);
return *this;
}
safe_VkCommandBufferBeginInfo::~safe_VkCommandBufferBeginInfo()
{
if (pInheritanceInfo)
delete pInheritanceInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCommandBufferBeginInfo::initialize(const VkCommandBufferBeginInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pInheritanceInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pInheritanceInfo)
pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
}
void safe_VkCommandBufferBeginInfo::initialize(const safe_VkCommandBufferBeginInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pInheritanceInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pInheritanceInfo)
pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src->pInheritanceInfo);
}
safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct) :
sType(in_struct->sType),
renderPass(in_struct->renderPass),
framebuffer(in_struct->framebuffer),
renderArea(in_struct->renderArea),
clearValueCount(in_struct->clearValueCount),
pClearValues(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pClearValues) {
pClearValues = new VkClearValue[in_struct->clearValueCount];
memcpy ((void *)pClearValues, (void *)in_struct->pClearValues, sizeof(VkClearValue)*in_struct->clearValueCount);
}
}
safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO),
pNext(nullptr),
pClearValues(nullptr)
{}
safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& copy_src)
{
sType = copy_src.sType;
renderPass = copy_src.renderPass;
framebuffer = copy_src.framebuffer;
renderArea = copy_src.renderArea;
clearValueCount = copy_src.clearValueCount;
pClearValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pClearValues) {
pClearValues = new VkClearValue[copy_src.clearValueCount];
memcpy ((void *)pClearValues, (void *)copy_src.pClearValues, sizeof(VkClearValue)*copy_src.clearValueCount);
}
}
safe_VkRenderPassBeginInfo& safe_VkRenderPassBeginInfo::operator=(const safe_VkRenderPassBeginInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pClearValues)
delete[] pClearValues;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
renderPass = copy_src.renderPass;
framebuffer = copy_src.framebuffer;
renderArea = copy_src.renderArea;
clearValueCount = copy_src.clearValueCount;
pClearValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pClearValues) {
pClearValues = new VkClearValue[copy_src.clearValueCount];
memcpy ((void *)pClearValues, (void *)copy_src.pClearValues, sizeof(VkClearValue)*copy_src.clearValueCount);
}
return *this;
}
safe_VkRenderPassBeginInfo::~safe_VkRenderPassBeginInfo()
{
if (pClearValues)
delete[] pClearValues;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassBeginInfo::initialize(const VkRenderPassBeginInfo* in_struct)
{
sType = in_struct->sType;
renderPass = in_struct->renderPass;
framebuffer = in_struct->framebuffer;
renderArea = in_struct->renderArea;
clearValueCount = in_struct->clearValueCount;
pClearValues = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pClearValues) {
pClearValues = new VkClearValue[in_struct->clearValueCount];
memcpy ((void *)pClearValues, (void *)in_struct->pClearValues, sizeof(VkClearValue)*in_struct->clearValueCount);
}
}
void safe_VkRenderPassBeginInfo::initialize(const safe_VkRenderPassBeginInfo* copy_src)
{
sType = copy_src->sType;
renderPass = copy_src->renderPass;
framebuffer = copy_src->framebuffer;
renderArea = copy_src->renderArea;
clearValueCount = copy_src->clearValueCount;
pClearValues = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pClearValues) {
pClearValues = new VkClearValue[copy_src->clearValueCount];
memcpy ((void *)pClearValues, (void *)copy_src->pClearValues, sizeof(VkClearValue)*copy_src->clearValueCount);
}
}
safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct) :
sType(in_struct->sType),
subgroupSize(in_struct->subgroupSize),
supportedStages(in_struct->supportedStages),
supportedOperations(in_struct->supportedOperations),
quadOperationsInAllStages(in_struct->quadOperationsInAllStages)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties(const safe_VkPhysicalDeviceSubgroupProperties& copy_src)
{
sType = copy_src.sType;
subgroupSize = copy_src.subgroupSize;
supportedStages = copy_src.supportedStages;
supportedOperations = copy_src.supportedOperations;
quadOperationsInAllStages = copy_src.quadOperationsInAllStages;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSubgroupProperties& safe_VkPhysicalDeviceSubgroupProperties::operator=(const safe_VkPhysicalDeviceSubgroupProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
subgroupSize = copy_src.subgroupSize;
supportedStages = copy_src.supportedStages;
supportedOperations = copy_src.supportedOperations;
quadOperationsInAllStages = copy_src.quadOperationsInAllStages;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSubgroupProperties::~safe_VkPhysicalDeviceSubgroupProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSubgroupProperties::initialize(const VkPhysicalDeviceSubgroupProperties* in_struct)
{
sType = in_struct->sType;
subgroupSize = in_struct->subgroupSize;
supportedStages = in_struct->supportedStages;
supportedOperations = in_struct->supportedOperations;
quadOperationsInAllStages = in_struct->quadOperationsInAllStages;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSubgroupProperties::initialize(const safe_VkPhysicalDeviceSubgroupProperties* copy_src)
{
sType = copy_src->sType;
subgroupSize = copy_src->subgroupSize;
supportedStages = copy_src->supportedStages;
supportedOperations = copy_src->supportedOperations;
quadOperationsInAllStages = copy_src->quadOperationsInAllStages;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct) :
sType(in_struct->sType),
buffer(in_struct->buffer),
memory(in_struct->memory),
memoryOffset(in_struct->memoryOffset)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo() :
sType(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO),
pNext(nullptr)
{}
safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& copy_src)
{
sType = copy_src.sType;
buffer = copy_src.buffer;
memory = copy_src.memory;
memoryOffset = copy_src.memoryOffset;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBindBufferMemoryInfo& safe_VkBindBufferMemoryInfo::operator=(const safe_VkBindBufferMemoryInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
buffer = copy_src.buffer;
memory = copy_src.memory;
memoryOffset = copy_src.memoryOffset;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBindBufferMemoryInfo::~safe_VkBindBufferMemoryInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBindBufferMemoryInfo::initialize(const VkBindBufferMemoryInfo* in_struct)
{
sType = in_struct->sType;
buffer = in_struct->buffer;
memory = in_struct->memory;
memoryOffset = in_struct->memoryOffset;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBindBufferMemoryInfo::initialize(const safe_VkBindBufferMemoryInfo* copy_src)
{
sType = copy_src->sType;
buffer = copy_src->buffer;
memory = copy_src->memory;
memoryOffset = copy_src->memoryOffset;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct) :
sType(in_struct->sType),
image(in_struct->image),
memory(in_struct->memory),
memoryOffset(in_struct->memoryOffset)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo() :
sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO),
pNext(nullptr)
{}
safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& copy_src)
{
sType = copy_src.sType;
image = copy_src.image;
memory = copy_src.memory;
memoryOffset = copy_src.memoryOffset;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBindImageMemoryInfo& safe_VkBindImageMemoryInfo::operator=(const safe_VkBindImageMemoryInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
image = copy_src.image;
memory = copy_src.memory;
memoryOffset = copy_src.memoryOffset;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBindImageMemoryInfo::~safe_VkBindImageMemoryInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBindImageMemoryInfo::initialize(const VkBindImageMemoryInfo* in_struct)
{
sType = in_struct->sType;
image = in_struct->image;
memory = in_struct->memory;
memoryOffset = in_struct->memoryOffset;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBindImageMemoryInfo::initialize(const safe_VkBindImageMemoryInfo* copy_src)
{
sType = copy_src->sType;
image = copy_src->image;
memory = copy_src->memory;
memoryOffset = copy_src->memoryOffset;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct) :
sType(in_struct->sType),
storageBuffer16BitAccess(in_struct->storageBuffer16BitAccess),
uniformAndStorageBuffer16BitAccess(in_struct->uniformAndStorageBuffer16BitAccess),
storagePushConstant16(in_struct->storagePushConstant16),
storageInputOutput16(in_struct->storageInputOutput16)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src)
{
sType = copy_src.sType;
storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess;
uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess;
storagePushConstant16 = copy_src.storagePushConstant16;
storageInputOutput16 = copy_src.storageInputOutput16;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevice16BitStorageFeatures& safe_VkPhysicalDevice16BitStorageFeatures::operator=(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess;
uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess;
storagePushConstant16 = copy_src.storagePushConstant16;
storageInputOutput16 = copy_src.storageInputOutput16;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevice16BitStorageFeatures::~safe_VkPhysicalDevice16BitStorageFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevice16BitStorageFeatures::initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct)
{
sType = in_struct->sType;
storageBuffer16BitAccess = in_struct->storageBuffer16BitAccess;
uniformAndStorageBuffer16BitAccess = in_struct->uniformAndStorageBuffer16BitAccess;
storagePushConstant16 = in_struct->storagePushConstant16;
storageInputOutput16 = in_struct->storageInputOutput16;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevice16BitStorageFeatures::initialize(const safe_VkPhysicalDevice16BitStorageFeatures* copy_src)
{
sType = copy_src->sType;
storageBuffer16BitAccess = copy_src->storageBuffer16BitAccess;
uniformAndStorageBuffer16BitAccess = copy_src->uniformAndStorageBuffer16BitAccess;
storagePushConstant16 = copy_src->storagePushConstant16;
storageInputOutput16 = copy_src->storageInputOutput16;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct) :
sType(in_struct->sType),
prefersDedicatedAllocation(in_struct->prefersDedicatedAllocation),
requiresDedicatedAllocation(in_struct->requiresDedicatedAllocation)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements() :
sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS),
pNext(nullptr)
{}
safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& copy_src)
{
sType = copy_src.sType;
prefersDedicatedAllocation = copy_src.prefersDedicatedAllocation;
requiresDedicatedAllocation = copy_src.requiresDedicatedAllocation;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryDedicatedRequirements& safe_VkMemoryDedicatedRequirements::operator=(const safe_VkMemoryDedicatedRequirements& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
prefersDedicatedAllocation = copy_src.prefersDedicatedAllocation;
requiresDedicatedAllocation = copy_src.requiresDedicatedAllocation;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryDedicatedRequirements::~safe_VkMemoryDedicatedRequirements()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryDedicatedRequirements::initialize(const VkMemoryDedicatedRequirements* in_struct)
{
sType = in_struct->sType;
prefersDedicatedAllocation = in_struct->prefersDedicatedAllocation;
requiresDedicatedAllocation = in_struct->requiresDedicatedAllocation;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryDedicatedRequirements::initialize(const safe_VkMemoryDedicatedRequirements* copy_src)
{
sType = copy_src->sType;
prefersDedicatedAllocation = copy_src->prefersDedicatedAllocation;
requiresDedicatedAllocation = copy_src->requiresDedicatedAllocation;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct) :
sType(in_struct->sType),
image(in_struct->image),
buffer(in_struct->buffer)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo() :
sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO),
pNext(nullptr)
{}
safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& copy_src)
{
sType = copy_src.sType;
image = copy_src.image;
buffer = copy_src.buffer;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryDedicatedAllocateInfo& safe_VkMemoryDedicatedAllocateInfo::operator=(const safe_VkMemoryDedicatedAllocateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
image = copy_src.image;
buffer = copy_src.buffer;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryDedicatedAllocateInfo::~safe_VkMemoryDedicatedAllocateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryDedicatedAllocateInfo::initialize(const VkMemoryDedicatedAllocateInfo* in_struct)
{
sType = in_struct->sType;
image = in_struct->image;
buffer = in_struct->buffer;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryDedicatedAllocateInfo::initialize(const safe_VkMemoryDedicatedAllocateInfo* copy_src)
{
sType = copy_src->sType;
image = copy_src->image;
buffer = copy_src->buffer;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
deviceMask(in_struct->deviceMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo() :
sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO),
pNext(nullptr)
{}
safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
deviceMask = copy_src.deviceMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryAllocateFlagsInfo& safe_VkMemoryAllocateFlagsInfo::operator=(const safe_VkMemoryAllocateFlagsInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
deviceMask = copy_src.deviceMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryAllocateFlagsInfo::~safe_VkMemoryAllocateFlagsInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryAllocateFlagsInfo::initialize(const VkMemoryAllocateFlagsInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
deviceMask = in_struct->deviceMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryAllocateFlagsInfo::initialize(const safe_VkMemoryAllocateFlagsInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
deviceMask = copy_src->deviceMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct) :
sType(in_struct->sType),
deviceMask(in_struct->deviceMask),
deviceRenderAreaCount(in_struct->deviceRenderAreaCount),
pDeviceRenderAreas(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceRenderAreas) {
pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount];
memcpy ((void *)pDeviceRenderAreas, (void *)in_struct->pDeviceRenderAreas, sizeof(VkRect2D)*in_struct->deviceRenderAreaCount);
}
}
safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo() :
sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO),
pNext(nullptr),
pDeviceRenderAreas(nullptr)
{}
safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src)
{
sType = copy_src.sType;
deviceMask = copy_src.deviceMask;
deviceRenderAreaCount = copy_src.deviceRenderAreaCount;
pDeviceRenderAreas = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceRenderAreas) {
pDeviceRenderAreas = new VkRect2D[copy_src.deviceRenderAreaCount];
memcpy ((void *)pDeviceRenderAreas, (void *)copy_src.pDeviceRenderAreas, sizeof(VkRect2D)*copy_src.deviceRenderAreaCount);
}
}
safe_VkDeviceGroupRenderPassBeginInfo& safe_VkDeviceGroupRenderPassBeginInfo::operator=(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pDeviceRenderAreas)
delete[] pDeviceRenderAreas;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceMask = copy_src.deviceMask;
deviceRenderAreaCount = copy_src.deviceRenderAreaCount;
pDeviceRenderAreas = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceRenderAreas) {
pDeviceRenderAreas = new VkRect2D[copy_src.deviceRenderAreaCount];
memcpy ((void *)pDeviceRenderAreas, (void *)copy_src.pDeviceRenderAreas, sizeof(VkRect2D)*copy_src.deviceRenderAreaCount);
}
return *this;
}
safe_VkDeviceGroupRenderPassBeginInfo::~safe_VkDeviceGroupRenderPassBeginInfo()
{
if (pDeviceRenderAreas)
delete[] pDeviceRenderAreas;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct)
{
sType = in_struct->sType;
deviceMask = in_struct->deviceMask;
deviceRenderAreaCount = in_struct->deviceRenderAreaCount;
pDeviceRenderAreas = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceRenderAreas) {
pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount];
memcpy ((void *)pDeviceRenderAreas, (void *)in_struct->pDeviceRenderAreas, sizeof(VkRect2D)*in_struct->deviceRenderAreaCount);
}
}
void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const safe_VkDeviceGroupRenderPassBeginInfo* copy_src)
{
sType = copy_src->sType;
deviceMask = copy_src->deviceMask;
deviceRenderAreaCount = copy_src->deviceRenderAreaCount;
pDeviceRenderAreas = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDeviceRenderAreas) {
pDeviceRenderAreas = new VkRect2D[copy_src->deviceRenderAreaCount];
memcpy ((void *)pDeviceRenderAreas, (void *)copy_src->pDeviceRenderAreas, sizeof(VkRect2D)*copy_src->deviceRenderAreaCount);
}
}
safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct) :
sType(in_struct->sType),
deviceMask(in_struct->deviceMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo() :
sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO),
pNext(nullptr)
{}
safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src)
{
sType = copy_src.sType;
deviceMask = copy_src.deviceMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceGroupCommandBufferBeginInfo& safe_VkDeviceGroupCommandBufferBeginInfo::operator=(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceMask = copy_src.deviceMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceGroupCommandBufferBeginInfo::~safe_VkDeviceGroupCommandBufferBeginInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceGroupCommandBufferBeginInfo::initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct)
{
sType = in_struct->sType;
deviceMask = in_struct->deviceMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceGroupCommandBufferBeginInfo::initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* copy_src)
{
sType = copy_src->sType;
deviceMask = copy_src->deviceMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct) :
sType(in_struct->sType),
waitSemaphoreCount(in_struct->waitSemaphoreCount),
pWaitSemaphoreDeviceIndices(nullptr),
commandBufferCount(in_struct->commandBufferCount),
pCommandBufferDeviceMasks(nullptr),
signalSemaphoreCount(in_struct->signalSemaphoreCount),
pSignalSemaphoreDeviceIndices(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pWaitSemaphoreDeviceIndices) {
pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount];
memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)in_struct->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->waitSemaphoreCount);
}
if (in_struct->pCommandBufferDeviceMasks) {
pCommandBufferDeviceMasks = new uint32_t[in_struct->commandBufferCount];
memcpy ((void *)pCommandBufferDeviceMasks, (void *)in_struct->pCommandBufferDeviceMasks, sizeof(uint32_t)*in_struct->commandBufferCount);
}
if (in_struct->pSignalSemaphoreDeviceIndices) {
pSignalSemaphoreDeviceIndices = new uint32_t[in_struct->signalSemaphoreCount];
memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)in_struct->pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->signalSemaphoreCount);
}
}
safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo() :
sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO),
pNext(nullptr),
pWaitSemaphoreDeviceIndices(nullptr),
pCommandBufferDeviceMasks(nullptr),
pSignalSemaphoreDeviceIndices(nullptr)
{}
safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& copy_src)
{
sType = copy_src.sType;
waitSemaphoreCount = copy_src.waitSemaphoreCount;
pWaitSemaphoreDeviceIndices = nullptr;
commandBufferCount = copy_src.commandBufferCount;
pCommandBufferDeviceMasks = nullptr;
signalSemaphoreCount = copy_src.signalSemaphoreCount;
pSignalSemaphoreDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pWaitSemaphoreDeviceIndices) {
pWaitSemaphoreDeviceIndices = new uint32_t[copy_src.waitSemaphoreCount];
memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)copy_src.pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*copy_src.waitSemaphoreCount);
}
if (copy_src.pCommandBufferDeviceMasks) {
pCommandBufferDeviceMasks = new uint32_t[copy_src.commandBufferCount];
memcpy ((void *)pCommandBufferDeviceMasks, (void *)copy_src.pCommandBufferDeviceMasks, sizeof(uint32_t)*copy_src.commandBufferCount);
}
if (copy_src.pSignalSemaphoreDeviceIndices) {
pSignalSemaphoreDeviceIndices = new uint32_t[copy_src.signalSemaphoreCount];
memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)copy_src.pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*copy_src.signalSemaphoreCount);
}
}
safe_VkDeviceGroupSubmitInfo& safe_VkDeviceGroupSubmitInfo::operator=(const safe_VkDeviceGroupSubmitInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pWaitSemaphoreDeviceIndices)
delete[] pWaitSemaphoreDeviceIndices;
if (pCommandBufferDeviceMasks)
delete[] pCommandBufferDeviceMasks;
if (pSignalSemaphoreDeviceIndices)
delete[] pSignalSemaphoreDeviceIndices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
waitSemaphoreCount = copy_src.waitSemaphoreCount;
pWaitSemaphoreDeviceIndices = nullptr;
commandBufferCount = copy_src.commandBufferCount;
pCommandBufferDeviceMasks = nullptr;
signalSemaphoreCount = copy_src.signalSemaphoreCount;
pSignalSemaphoreDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pWaitSemaphoreDeviceIndices) {
pWaitSemaphoreDeviceIndices = new uint32_t[copy_src.waitSemaphoreCount];
memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)copy_src.pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*copy_src.waitSemaphoreCount);
}
if (copy_src.pCommandBufferDeviceMasks) {
pCommandBufferDeviceMasks = new uint32_t[copy_src.commandBufferCount];
memcpy ((void *)pCommandBufferDeviceMasks, (void *)copy_src.pCommandBufferDeviceMasks, sizeof(uint32_t)*copy_src.commandBufferCount);
}
if (copy_src.pSignalSemaphoreDeviceIndices) {
pSignalSemaphoreDeviceIndices = new uint32_t[copy_src.signalSemaphoreCount];
memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)copy_src.pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*copy_src.signalSemaphoreCount);
}
return *this;
}
safe_VkDeviceGroupSubmitInfo::~safe_VkDeviceGroupSubmitInfo()
{
if (pWaitSemaphoreDeviceIndices)
delete[] pWaitSemaphoreDeviceIndices;
if (pCommandBufferDeviceMasks)
delete[] pCommandBufferDeviceMasks;
if (pSignalSemaphoreDeviceIndices)
delete[] pSignalSemaphoreDeviceIndices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceGroupSubmitInfo::initialize(const VkDeviceGroupSubmitInfo* in_struct)
{
sType = in_struct->sType;
waitSemaphoreCount = in_struct->waitSemaphoreCount;
pWaitSemaphoreDeviceIndices = nullptr;
commandBufferCount = in_struct->commandBufferCount;
pCommandBufferDeviceMasks = nullptr;
signalSemaphoreCount = in_struct->signalSemaphoreCount;
pSignalSemaphoreDeviceIndices = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pWaitSemaphoreDeviceIndices) {
pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount];
memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)in_struct->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->waitSemaphoreCount);
}
if (in_struct->pCommandBufferDeviceMasks) {
pCommandBufferDeviceMasks = new uint32_t[in_struct->commandBufferCount];
memcpy ((void *)pCommandBufferDeviceMasks, (void *)in_struct->pCommandBufferDeviceMasks, sizeof(uint32_t)*in_struct->commandBufferCount);
}
if (in_struct->pSignalSemaphoreDeviceIndices) {
pSignalSemaphoreDeviceIndices = new uint32_t[in_struct->signalSemaphoreCount];
memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)in_struct->pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->signalSemaphoreCount);
}
}
void safe_VkDeviceGroupSubmitInfo::initialize(const safe_VkDeviceGroupSubmitInfo* copy_src)
{
sType = copy_src->sType;
waitSemaphoreCount = copy_src->waitSemaphoreCount;
pWaitSemaphoreDeviceIndices = nullptr;
commandBufferCount = copy_src->commandBufferCount;
pCommandBufferDeviceMasks = nullptr;
signalSemaphoreCount = copy_src->signalSemaphoreCount;
pSignalSemaphoreDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pWaitSemaphoreDeviceIndices) {
pWaitSemaphoreDeviceIndices = new uint32_t[copy_src->waitSemaphoreCount];
memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)copy_src->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*copy_src->waitSemaphoreCount);
}
if (copy_src->pCommandBufferDeviceMasks) {
pCommandBufferDeviceMasks = new uint32_t[copy_src->commandBufferCount];
memcpy ((void *)pCommandBufferDeviceMasks, (void *)copy_src->pCommandBufferDeviceMasks, sizeof(uint32_t)*copy_src->commandBufferCount);
}
if (copy_src->pSignalSemaphoreDeviceIndices) {
pSignalSemaphoreDeviceIndices = new uint32_t[copy_src->signalSemaphoreCount];
memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)copy_src->pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*copy_src->signalSemaphoreCount);
}
}
safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct) :
sType(in_struct->sType),
resourceDeviceIndex(in_struct->resourceDeviceIndex),
memoryDeviceIndex(in_struct->memoryDeviceIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo() :
sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO),
pNext(nullptr)
{}
safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& copy_src)
{
sType = copy_src.sType;
resourceDeviceIndex = copy_src.resourceDeviceIndex;
memoryDeviceIndex = copy_src.memoryDeviceIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceGroupBindSparseInfo& safe_VkDeviceGroupBindSparseInfo::operator=(const safe_VkDeviceGroupBindSparseInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
resourceDeviceIndex = copy_src.resourceDeviceIndex;
memoryDeviceIndex = copy_src.memoryDeviceIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceGroupBindSparseInfo::~safe_VkDeviceGroupBindSparseInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceGroupBindSparseInfo::initialize(const VkDeviceGroupBindSparseInfo* in_struct)
{
sType = in_struct->sType;
resourceDeviceIndex = in_struct->resourceDeviceIndex;
memoryDeviceIndex = in_struct->memoryDeviceIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceGroupBindSparseInfo::initialize(const safe_VkDeviceGroupBindSparseInfo* copy_src)
{
sType = copy_src->sType;
resourceDeviceIndex = copy_src->resourceDeviceIndex;
memoryDeviceIndex = copy_src->memoryDeviceIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct) :
sType(in_struct->sType),
deviceIndexCount(in_struct->deviceIndexCount),
pDeviceIndices(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceIndices) {
pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
}
}
safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo() :
sType(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO),
pNext(nullptr),
pDeviceIndices(nullptr)
{}
safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src)
{
sType = copy_src.sType;
deviceIndexCount = copy_src.deviceIndexCount;
pDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src.pDeviceIndices, sizeof(uint32_t)*copy_src.deviceIndexCount);
}
}
safe_VkBindBufferMemoryDeviceGroupInfo& safe_VkBindBufferMemoryDeviceGroupInfo::operator=(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pDeviceIndices)
delete[] pDeviceIndices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceIndexCount = copy_src.deviceIndexCount;
pDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src.pDeviceIndices, sizeof(uint32_t)*copy_src.deviceIndexCount);
}
return *this;
}
safe_VkBindBufferMemoryDeviceGroupInfo::~safe_VkBindBufferMemoryDeviceGroupInfo()
{
if (pDeviceIndices)
delete[] pDeviceIndices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct)
{
sType = in_struct->sType;
deviceIndexCount = in_struct->deviceIndexCount;
pDeviceIndices = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceIndices) {
pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
}
}
void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* copy_src)
{
sType = copy_src->sType;
deviceIndexCount = copy_src->deviceIndexCount;
pDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src->pDeviceIndices, sizeof(uint32_t)*copy_src->deviceIndexCount);
}
}
safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct) :
sType(in_struct->sType),
deviceIndexCount(in_struct->deviceIndexCount),
pDeviceIndices(nullptr),
splitInstanceBindRegionCount(in_struct->splitInstanceBindRegionCount),
pSplitInstanceBindRegions(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceIndices) {
pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
}
if (in_struct->pSplitInstanceBindRegions) {
pSplitInstanceBindRegions = new VkRect2D[in_struct->splitInstanceBindRegionCount];
memcpy ((void *)pSplitInstanceBindRegions, (void *)in_struct->pSplitInstanceBindRegions, sizeof(VkRect2D)*in_struct->splitInstanceBindRegionCount);
}
}
safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo() :
sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO),
pNext(nullptr),
pDeviceIndices(nullptr),
pSplitInstanceBindRegions(nullptr)
{}
safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src)
{
sType = copy_src.sType;
deviceIndexCount = copy_src.deviceIndexCount;
pDeviceIndices = nullptr;
splitInstanceBindRegionCount = copy_src.splitInstanceBindRegionCount;
pSplitInstanceBindRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src.pDeviceIndices, sizeof(uint32_t)*copy_src.deviceIndexCount);
}
if (copy_src.pSplitInstanceBindRegions) {
pSplitInstanceBindRegions = new VkRect2D[copy_src.splitInstanceBindRegionCount];
memcpy ((void *)pSplitInstanceBindRegions, (void *)copy_src.pSplitInstanceBindRegions, sizeof(VkRect2D)*copy_src.splitInstanceBindRegionCount);
}
}
safe_VkBindImageMemoryDeviceGroupInfo& safe_VkBindImageMemoryDeviceGroupInfo::operator=(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pDeviceIndices)
delete[] pDeviceIndices;
if (pSplitInstanceBindRegions)
delete[] pSplitInstanceBindRegions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceIndexCount = copy_src.deviceIndexCount;
pDeviceIndices = nullptr;
splitInstanceBindRegionCount = copy_src.splitInstanceBindRegionCount;
pSplitInstanceBindRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src.pDeviceIndices, sizeof(uint32_t)*copy_src.deviceIndexCount);
}
if (copy_src.pSplitInstanceBindRegions) {
pSplitInstanceBindRegions = new VkRect2D[copy_src.splitInstanceBindRegionCount];
memcpy ((void *)pSplitInstanceBindRegions, (void *)copy_src.pSplitInstanceBindRegions, sizeof(VkRect2D)*copy_src.splitInstanceBindRegionCount);
}
return *this;
}
safe_VkBindImageMemoryDeviceGroupInfo::~safe_VkBindImageMemoryDeviceGroupInfo()
{
if (pDeviceIndices)
delete[] pDeviceIndices;
if (pSplitInstanceBindRegions)
delete[] pSplitInstanceBindRegions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct)
{
sType = in_struct->sType;
deviceIndexCount = in_struct->deviceIndexCount;
pDeviceIndices = nullptr;
splitInstanceBindRegionCount = in_struct->splitInstanceBindRegionCount;
pSplitInstanceBindRegions = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceIndices) {
pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
}
if (in_struct->pSplitInstanceBindRegions) {
pSplitInstanceBindRegions = new VkRect2D[in_struct->splitInstanceBindRegionCount];
memcpy ((void *)pSplitInstanceBindRegions, (void *)in_struct->pSplitInstanceBindRegions, sizeof(VkRect2D)*in_struct->splitInstanceBindRegionCount);
}
}
void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const safe_VkBindImageMemoryDeviceGroupInfo* copy_src)
{
sType = copy_src->sType;
deviceIndexCount = copy_src->deviceIndexCount;
pDeviceIndices = nullptr;
splitInstanceBindRegionCount = copy_src->splitInstanceBindRegionCount;
pSplitInstanceBindRegions = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src->pDeviceIndices, sizeof(uint32_t)*copy_src->deviceIndexCount);
}
if (copy_src->pSplitInstanceBindRegions) {
pSplitInstanceBindRegions = new VkRect2D[copy_src->splitInstanceBindRegionCount];
memcpy ((void *)pSplitInstanceBindRegions, (void *)copy_src->pSplitInstanceBindRegions, sizeof(VkRect2D)*copy_src->splitInstanceBindRegionCount);
}
}
safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct) :
sType(in_struct->sType),
physicalDeviceCount(in_struct->physicalDeviceCount),
subsetAllocation(in_struct->subsetAllocation)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
physicalDevices[i] = in_struct->physicalDevices[i];
}
}
safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& copy_src)
{
sType = copy_src.sType;
physicalDeviceCount = copy_src.physicalDeviceCount;
subsetAllocation = copy_src.subsetAllocation;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
physicalDevices[i] = copy_src.physicalDevices[i];
}
}
safe_VkPhysicalDeviceGroupProperties& safe_VkPhysicalDeviceGroupProperties::operator=(const safe_VkPhysicalDeviceGroupProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
physicalDeviceCount = copy_src.physicalDeviceCount;
subsetAllocation = copy_src.subsetAllocation;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
physicalDevices[i] = copy_src.physicalDevices[i];
}
return *this;
}
safe_VkPhysicalDeviceGroupProperties::~safe_VkPhysicalDeviceGroupProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceGroupProperties::initialize(const VkPhysicalDeviceGroupProperties* in_struct)
{
sType = in_struct->sType;
physicalDeviceCount = in_struct->physicalDeviceCount;
subsetAllocation = in_struct->subsetAllocation;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
physicalDevices[i] = in_struct->physicalDevices[i];
}
}
void safe_VkPhysicalDeviceGroupProperties::initialize(const safe_VkPhysicalDeviceGroupProperties* copy_src)
{
sType = copy_src->sType;
physicalDeviceCount = copy_src->physicalDeviceCount;
subsetAllocation = copy_src->subsetAllocation;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
physicalDevices[i] = copy_src->physicalDevices[i];
}
}
safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct) :
sType(in_struct->sType),
physicalDeviceCount(in_struct->physicalDeviceCount),
pPhysicalDevices(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPhysicalDevices) {
pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount];
memcpy ((void *)pPhysicalDevices, (void *)in_struct->pPhysicalDevices, sizeof(VkPhysicalDevice)*in_struct->physicalDeviceCount);
}
}
safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo() :
sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO),
pNext(nullptr),
pPhysicalDevices(nullptr)
{}
safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& copy_src)
{
sType = copy_src.sType;
physicalDeviceCount = copy_src.physicalDeviceCount;
pPhysicalDevices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPhysicalDevices) {
pPhysicalDevices = new VkPhysicalDevice[copy_src.physicalDeviceCount];
memcpy ((void *)pPhysicalDevices, (void *)copy_src.pPhysicalDevices, sizeof(VkPhysicalDevice)*copy_src.physicalDeviceCount);
}
}
safe_VkDeviceGroupDeviceCreateInfo& safe_VkDeviceGroupDeviceCreateInfo::operator=(const safe_VkDeviceGroupDeviceCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pPhysicalDevices)
delete[] pPhysicalDevices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
physicalDeviceCount = copy_src.physicalDeviceCount;
pPhysicalDevices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPhysicalDevices) {
pPhysicalDevices = new VkPhysicalDevice[copy_src.physicalDeviceCount];
memcpy ((void *)pPhysicalDevices, (void *)copy_src.pPhysicalDevices, sizeof(VkPhysicalDevice)*copy_src.physicalDeviceCount);
}
return *this;
}
safe_VkDeviceGroupDeviceCreateInfo::~safe_VkDeviceGroupDeviceCreateInfo()
{
if (pPhysicalDevices)
delete[] pPhysicalDevices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceGroupDeviceCreateInfo::initialize(const VkDeviceGroupDeviceCreateInfo* in_struct)
{
sType = in_struct->sType;
physicalDeviceCount = in_struct->physicalDeviceCount;
pPhysicalDevices = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPhysicalDevices) {
pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount];
memcpy ((void *)pPhysicalDevices, (void *)in_struct->pPhysicalDevices, sizeof(VkPhysicalDevice)*in_struct->physicalDeviceCount);
}
}
void safe_VkDeviceGroupDeviceCreateInfo::initialize(const safe_VkDeviceGroupDeviceCreateInfo* copy_src)
{
sType = copy_src->sType;
physicalDeviceCount = copy_src->physicalDeviceCount;
pPhysicalDevices = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pPhysicalDevices) {
pPhysicalDevices = new VkPhysicalDevice[copy_src->physicalDeviceCount];
memcpy ((void *)pPhysicalDevices, (void *)copy_src->pPhysicalDevices, sizeof(VkPhysicalDevice)*copy_src->physicalDeviceCount);
}
}
safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct) :
sType(in_struct->sType),
buffer(in_struct->buffer)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2() :
sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2),
pNext(nullptr)
{}
safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& copy_src)
{
sType = copy_src.sType;
buffer = copy_src.buffer;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferMemoryRequirementsInfo2& safe_VkBufferMemoryRequirementsInfo2::operator=(const safe_VkBufferMemoryRequirementsInfo2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
buffer = copy_src.buffer;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferMemoryRequirementsInfo2::~safe_VkBufferMemoryRequirementsInfo2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferMemoryRequirementsInfo2::initialize(const VkBufferMemoryRequirementsInfo2* in_struct)
{
sType = in_struct->sType;
buffer = in_struct->buffer;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferMemoryRequirementsInfo2::initialize(const safe_VkBufferMemoryRequirementsInfo2* copy_src)
{
sType = copy_src->sType;
buffer = copy_src->buffer;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct) :
sType(in_struct->sType),
image(in_struct->image)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2() :
sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2),
pNext(nullptr)
{}
safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& copy_src)
{
sType = copy_src.sType;
image = copy_src.image;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageMemoryRequirementsInfo2& safe_VkImageMemoryRequirementsInfo2::operator=(const safe_VkImageMemoryRequirementsInfo2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
image = copy_src.image;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageMemoryRequirementsInfo2::~safe_VkImageMemoryRequirementsInfo2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageMemoryRequirementsInfo2::initialize(const VkImageMemoryRequirementsInfo2* in_struct)
{
sType = in_struct->sType;
image = in_struct->image;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageMemoryRequirementsInfo2::initialize(const safe_VkImageMemoryRequirementsInfo2* copy_src)
{
sType = copy_src->sType;
image = copy_src->image;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct) :
sType(in_struct->sType),
image(in_struct->image)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2() :
sType(VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2),
pNext(nullptr)
{}
safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src)
{
sType = copy_src.sType;
image = copy_src.image;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageSparseMemoryRequirementsInfo2& safe_VkImageSparseMemoryRequirementsInfo2::operator=(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
image = copy_src.image;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageSparseMemoryRequirementsInfo2::~safe_VkImageSparseMemoryRequirementsInfo2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageSparseMemoryRequirementsInfo2::initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct)
{
sType = in_struct->sType;
image = in_struct->image;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageSparseMemoryRequirementsInfo2::initialize(const safe_VkImageSparseMemoryRequirementsInfo2* copy_src)
{
sType = copy_src->sType;
image = copy_src->image;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryRequirements2::safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct) :
sType(in_struct->sType),
memoryRequirements(in_struct->memoryRequirements)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryRequirements2::safe_VkMemoryRequirements2() :
sType(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2),
pNext(nullptr)
{}
safe_VkMemoryRequirements2::safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& copy_src)
{
sType = copy_src.sType;
memoryRequirements = copy_src.memoryRequirements;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryRequirements2& safe_VkMemoryRequirements2::operator=(const safe_VkMemoryRequirements2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryRequirements = copy_src.memoryRequirements;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryRequirements2::~safe_VkMemoryRequirements2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryRequirements2::initialize(const VkMemoryRequirements2* in_struct)
{
sType = in_struct->sType;
memoryRequirements = in_struct->memoryRequirements;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryRequirements2::initialize(const safe_VkMemoryRequirements2* copy_src)
{
sType = copy_src->sType;
memoryRequirements = copy_src->memoryRequirements;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct) :
sType(in_struct->sType),
memoryRequirements(in_struct->memoryRequirements)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2() :
sType(VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2),
pNext(nullptr)
{}
safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2(const safe_VkSparseImageMemoryRequirements2& copy_src)
{
sType = copy_src.sType;
memoryRequirements = copy_src.memoryRequirements;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSparseImageMemoryRequirements2& safe_VkSparseImageMemoryRequirements2::operator=(const safe_VkSparseImageMemoryRequirements2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryRequirements = copy_src.memoryRequirements;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSparseImageMemoryRequirements2::~safe_VkSparseImageMemoryRequirements2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSparseImageMemoryRequirements2::initialize(const VkSparseImageMemoryRequirements2* in_struct)
{
sType = in_struct->sType;
memoryRequirements = in_struct->memoryRequirements;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSparseImageMemoryRequirements2::initialize(const safe_VkSparseImageMemoryRequirements2* copy_src)
{
sType = copy_src->sType;
memoryRequirements = copy_src->memoryRequirements;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct) :
sType(in_struct->sType),
features(in_struct->features)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& copy_src)
{
sType = copy_src.sType;
features = copy_src.features;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFeatures2& safe_VkPhysicalDeviceFeatures2::operator=(const safe_VkPhysicalDeviceFeatures2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
features = copy_src.features;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFeatures2::~safe_VkPhysicalDeviceFeatures2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFeatures2::initialize(const VkPhysicalDeviceFeatures2* in_struct)
{
sType = in_struct->sType;
features = in_struct->features;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFeatures2::initialize(const safe_VkPhysicalDeviceFeatures2* copy_src)
{
sType = copy_src->sType;
features = copy_src->features;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct) :
sType(in_struct->sType),
properties(in_struct->properties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2),
pNext(nullptr)
{}
safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& copy_src)
{
sType = copy_src.sType;
properties = copy_src.properties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceProperties2& safe_VkPhysicalDeviceProperties2::operator=(const safe_VkPhysicalDeviceProperties2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
properties = copy_src.properties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceProperties2::~safe_VkPhysicalDeviceProperties2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceProperties2::initialize(const VkPhysicalDeviceProperties2* in_struct)
{
sType = in_struct->sType;
properties = in_struct->properties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceProperties2::initialize(const safe_VkPhysicalDeviceProperties2* copy_src)
{
sType = copy_src->sType;
properties = copy_src->properties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkFormatProperties2::safe_VkFormatProperties2(const VkFormatProperties2* in_struct) :
sType(in_struct->sType),
formatProperties(in_struct->formatProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkFormatProperties2::safe_VkFormatProperties2() :
sType(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2),
pNext(nullptr)
{}
safe_VkFormatProperties2::safe_VkFormatProperties2(const safe_VkFormatProperties2& copy_src)
{
sType = copy_src.sType;
formatProperties = copy_src.formatProperties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkFormatProperties2& safe_VkFormatProperties2::operator=(const safe_VkFormatProperties2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
formatProperties = copy_src.formatProperties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkFormatProperties2::~safe_VkFormatProperties2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFormatProperties2::initialize(const VkFormatProperties2* in_struct)
{
sType = in_struct->sType;
formatProperties = in_struct->formatProperties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkFormatProperties2::initialize(const safe_VkFormatProperties2* copy_src)
{
sType = copy_src->sType;
formatProperties = copy_src->formatProperties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageFormatProperties2::safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct) :
sType(in_struct->sType),
imageFormatProperties(in_struct->imageFormatProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageFormatProperties2::safe_VkImageFormatProperties2() :
sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2),
pNext(nullptr)
{}
safe_VkImageFormatProperties2::safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& copy_src)
{
sType = copy_src.sType;
imageFormatProperties = copy_src.imageFormatProperties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageFormatProperties2& safe_VkImageFormatProperties2::operator=(const safe_VkImageFormatProperties2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
imageFormatProperties = copy_src.imageFormatProperties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageFormatProperties2::~safe_VkImageFormatProperties2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageFormatProperties2::initialize(const VkImageFormatProperties2* in_struct)
{
sType = in_struct->sType;
imageFormatProperties = in_struct->imageFormatProperties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageFormatProperties2::initialize(const safe_VkImageFormatProperties2* copy_src)
{
sType = copy_src->sType;
imageFormatProperties = copy_src->imageFormatProperties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct) :
sType(in_struct->sType),
format(in_struct->format),
type(in_struct->type),
tiling(in_struct->tiling),
usage(in_struct->usage),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2),
pNext(nullptr)
{}
safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src)
{
sType = copy_src.sType;
format = copy_src.format;
type = copy_src.type;
tiling = copy_src.tiling;
usage = copy_src.usage;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceImageFormatInfo2& safe_VkPhysicalDeviceImageFormatInfo2::operator=(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
format = copy_src.format;
type = copy_src.type;
tiling = copy_src.tiling;
usage = copy_src.usage;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceImageFormatInfo2::~safe_VkPhysicalDeviceImageFormatInfo2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceImageFormatInfo2::initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct)
{
sType = in_struct->sType;
format = in_struct->format;
type = in_struct->type;
tiling = in_struct->tiling;
usage = in_struct->usage;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceImageFormatInfo2::initialize(const safe_VkPhysicalDeviceImageFormatInfo2* copy_src)
{
sType = copy_src->sType;
format = copy_src->format;
type = copy_src->type;
tiling = copy_src->tiling;
usage = copy_src->usage;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct) :
sType(in_struct->sType),
queueFamilyProperties(in_struct->queueFamilyProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2() :
sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2),
pNext(nullptr)
{}
safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& copy_src)
{
sType = copy_src.sType;
queueFamilyProperties = copy_src.queueFamilyProperties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkQueueFamilyProperties2& safe_VkQueueFamilyProperties2::operator=(const safe_VkQueueFamilyProperties2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
queueFamilyProperties = copy_src.queueFamilyProperties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkQueueFamilyProperties2::~safe_VkQueueFamilyProperties2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkQueueFamilyProperties2::initialize(const VkQueueFamilyProperties2* in_struct)
{
sType = in_struct->sType;
queueFamilyProperties = in_struct->queueFamilyProperties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkQueueFamilyProperties2::initialize(const safe_VkQueueFamilyProperties2* copy_src)
{
sType = copy_src->sType;
queueFamilyProperties = copy_src->queueFamilyProperties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct) :
sType(in_struct->sType),
memoryProperties(in_struct->memoryProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2(const safe_VkPhysicalDeviceMemoryProperties2& copy_src)
{
sType = copy_src.sType;
memoryProperties = copy_src.memoryProperties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceMemoryProperties2& safe_VkPhysicalDeviceMemoryProperties2::operator=(const safe_VkPhysicalDeviceMemoryProperties2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryProperties = copy_src.memoryProperties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceMemoryProperties2::~safe_VkPhysicalDeviceMemoryProperties2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMemoryProperties2::initialize(const VkPhysicalDeviceMemoryProperties2* in_struct)
{
sType = in_struct->sType;
memoryProperties = in_struct->memoryProperties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceMemoryProperties2::initialize(const safe_VkPhysicalDeviceMemoryProperties2* copy_src)
{
sType = copy_src->sType;
memoryProperties = copy_src->memoryProperties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct) :
sType(in_struct->sType),
properties(in_struct->properties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2() :
sType(VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2),
pNext(nullptr)
{}
safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& copy_src)
{
sType = copy_src.sType;
properties = copy_src.properties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSparseImageFormatProperties2& safe_VkSparseImageFormatProperties2::operator=(const safe_VkSparseImageFormatProperties2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
properties = copy_src.properties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSparseImageFormatProperties2::~safe_VkSparseImageFormatProperties2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSparseImageFormatProperties2::initialize(const VkSparseImageFormatProperties2* in_struct)
{
sType = in_struct->sType;
properties = in_struct->properties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSparseImageFormatProperties2::initialize(const safe_VkSparseImageFormatProperties2* copy_src)
{
sType = copy_src->sType;
properties = copy_src->properties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct) :
sType(in_struct->sType),
format(in_struct->format),
type(in_struct->type),
samples(in_struct->samples),
usage(in_struct->usage),
tiling(in_struct->tiling)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src)
{
sType = copy_src.sType;
format = copy_src.format;
type = copy_src.type;
samples = copy_src.samples;
usage = copy_src.usage;
tiling = copy_src.tiling;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSparseImageFormatInfo2& safe_VkPhysicalDeviceSparseImageFormatInfo2::operator=(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
format = copy_src.format;
type = copy_src.type;
samples = copy_src.samples;
usage = copy_src.usage;
tiling = copy_src.tiling;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSparseImageFormatInfo2::~safe_VkPhysicalDeviceSparseImageFormatInfo2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSparseImageFormatInfo2::initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct)
{
sType = in_struct->sType;
format = in_struct->format;
type = in_struct->type;
samples = in_struct->samples;
usage = in_struct->usage;
tiling = in_struct->tiling;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSparseImageFormatInfo2::initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* copy_src)
{
sType = copy_src->sType;
format = copy_src->format;
type = copy_src->type;
samples = copy_src->samples;
usage = copy_src->usage;
tiling = copy_src->tiling;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct) :
sType(in_struct->sType),
pointClippingBehavior(in_struct->pointClippingBehavior)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties(const safe_VkPhysicalDevicePointClippingProperties& copy_src)
{
sType = copy_src.sType;
pointClippingBehavior = copy_src.pointClippingBehavior;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePointClippingProperties& safe_VkPhysicalDevicePointClippingProperties::operator=(const safe_VkPhysicalDevicePointClippingProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pointClippingBehavior = copy_src.pointClippingBehavior;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePointClippingProperties::~safe_VkPhysicalDevicePointClippingProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePointClippingProperties::initialize(const VkPhysicalDevicePointClippingProperties* in_struct)
{
sType = in_struct->sType;
pointClippingBehavior = in_struct->pointClippingBehavior;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePointClippingProperties::initialize(const safe_VkPhysicalDevicePointClippingProperties* copy_src)
{
sType = copy_src->sType;
pointClippingBehavior = copy_src->pointClippingBehavior;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct) :
sType(in_struct->sType),
aspectReferenceCount(in_struct->aspectReferenceCount),
pAspectReferences(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAspectReferences) {
pAspectReferences = new VkInputAttachmentAspectReference[in_struct->aspectReferenceCount];
memcpy ((void *)pAspectReferences, (void *)in_struct->pAspectReferences, sizeof(VkInputAttachmentAspectReference)*in_struct->aspectReferenceCount);
}
}
safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO),
pNext(nullptr),
pAspectReferences(nullptr)
{}
safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src)
{
sType = copy_src.sType;
aspectReferenceCount = copy_src.aspectReferenceCount;
pAspectReferences = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAspectReferences) {
pAspectReferences = new VkInputAttachmentAspectReference[copy_src.aspectReferenceCount];
memcpy ((void *)pAspectReferences, (void *)copy_src.pAspectReferences, sizeof(VkInputAttachmentAspectReference)*copy_src.aspectReferenceCount);
}
}
safe_VkRenderPassInputAttachmentAspectCreateInfo& safe_VkRenderPassInputAttachmentAspectCreateInfo::operator=(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pAspectReferences)
delete[] pAspectReferences;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
aspectReferenceCount = copy_src.aspectReferenceCount;
pAspectReferences = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAspectReferences) {
pAspectReferences = new VkInputAttachmentAspectReference[copy_src.aspectReferenceCount];
memcpy ((void *)pAspectReferences, (void *)copy_src.pAspectReferences, sizeof(VkInputAttachmentAspectReference)*copy_src.aspectReferenceCount);
}
return *this;
}
safe_VkRenderPassInputAttachmentAspectCreateInfo::~safe_VkRenderPassInputAttachmentAspectCreateInfo()
{
if (pAspectReferences)
delete[] pAspectReferences;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct)
{
sType = in_struct->sType;
aspectReferenceCount = in_struct->aspectReferenceCount;
pAspectReferences = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAspectReferences) {
pAspectReferences = new VkInputAttachmentAspectReference[in_struct->aspectReferenceCount];
memcpy ((void *)pAspectReferences, (void *)in_struct->pAspectReferences, sizeof(VkInputAttachmentAspectReference)*in_struct->aspectReferenceCount);
}
}
void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* copy_src)
{
sType = copy_src->sType;
aspectReferenceCount = copy_src->aspectReferenceCount;
pAspectReferences = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pAspectReferences) {
pAspectReferences = new VkInputAttachmentAspectReference[copy_src->aspectReferenceCount];
memcpy ((void *)pAspectReferences, (void *)copy_src->pAspectReferences, sizeof(VkInputAttachmentAspectReference)*copy_src->aspectReferenceCount);
}
}
safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct) :
sType(in_struct->sType),
usage(in_struct->usage)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo() :
sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& copy_src)
{
sType = copy_src.sType;
usage = copy_src.usage;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageViewUsageCreateInfo& safe_VkImageViewUsageCreateInfo::operator=(const safe_VkImageViewUsageCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
usage = copy_src.usage;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageViewUsageCreateInfo::~safe_VkImageViewUsageCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageViewUsageCreateInfo::initialize(const VkImageViewUsageCreateInfo* in_struct)
{
sType = in_struct->sType;
usage = in_struct->usage;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageViewUsageCreateInfo::initialize(const safe_VkImageViewUsageCreateInfo* copy_src)
{
sType = copy_src->sType;
usage = copy_src->usage;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct) :
sType(in_struct->sType),
domainOrigin(in_struct->domainOrigin)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo() :
sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src)
{
sType = copy_src.sType;
domainOrigin = copy_src.domainOrigin;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineTessellationDomainOriginStateCreateInfo& safe_VkPipelineTessellationDomainOriginStateCreateInfo::operator=(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
domainOrigin = copy_src.domainOrigin;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineTessellationDomainOriginStateCreateInfo::~safe_VkPipelineTessellationDomainOriginStateCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineTessellationDomainOriginStateCreateInfo::initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct)
{
sType = in_struct->sType;
domainOrigin = in_struct->domainOrigin;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineTessellationDomainOriginStateCreateInfo::initialize(const safe_VkPipelineTessellationDomainOriginStateCreateInfo* copy_src)
{
sType = copy_src->sType;
domainOrigin = copy_src->domainOrigin;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct) :
sType(in_struct->sType),
subpassCount(in_struct->subpassCount),
pViewMasks(nullptr),
dependencyCount(in_struct->dependencyCount),
pViewOffsets(nullptr),
correlationMaskCount(in_struct->correlationMaskCount),
pCorrelationMasks(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewMasks) {
pViewMasks = new uint32_t[in_struct->subpassCount];
memcpy ((void *)pViewMasks, (void *)in_struct->pViewMasks, sizeof(uint32_t)*in_struct->subpassCount);
}
if (in_struct->pViewOffsets) {
pViewOffsets = new int32_t[in_struct->dependencyCount];
memcpy ((void *)pViewOffsets, (void *)in_struct->pViewOffsets, sizeof(int32_t)*in_struct->dependencyCount);
}
if (in_struct->pCorrelationMasks) {
pCorrelationMasks = new uint32_t[in_struct->correlationMaskCount];
memcpy ((void *)pCorrelationMasks, (void *)in_struct->pCorrelationMasks, sizeof(uint32_t)*in_struct->correlationMaskCount);
}
}
safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO),
pNext(nullptr),
pViewMasks(nullptr),
pViewOffsets(nullptr),
pCorrelationMasks(nullptr)
{}
safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& copy_src)
{
sType = copy_src.sType;
subpassCount = copy_src.subpassCount;
pViewMasks = nullptr;
dependencyCount = copy_src.dependencyCount;
pViewOffsets = nullptr;
correlationMaskCount = copy_src.correlationMaskCount;
pCorrelationMasks = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewMasks) {
pViewMasks = new uint32_t[copy_src.subpassCount];
memcpy ((void *)pViewMasks, (void *)copy_src.pViewMasks, sizeof(uint32_t)*copy_src.subpassCount);
}
if (copy_src.pViewOffsets) {
pViewOffsets = new int32_t[copy_src.dependencyCount];
memcpy ((void *)pViewOffsets, (void *)copy_src.pViewOffsets, sizeof(int32_t)*copy_src.dependencyCount);
}
if (copy_src.pCorrelationMasks) {
pCorrelationMasks = new uint32_t[copy_src.correlationMaskCount];
memcpy ((void *)pCorrelationMasks, (void *)copy_src.pCorrelationMasks, sizeof(uint32_t)*copy_src.correlationMaskCount);
}
}
safe_VkRenderPassMultiviewCreateInfo& safe_VkRenderPassMultiviewCreateInfo::operator=(const safe_VkRenderPassMultiviewCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pViewMasks)
delete[] pViewMasks;
if (pViewOffsets)
delete[] pViewOffsets;
if (pCorrelationMasks)
delete[] pCorrelationMasks;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
subpassCount = copy_src.subpassCount;
pViewMasks = nullptr;
dependencyCount = copy_src.dependencyCount;
pViewOffsets = nullptr;
correlationMaskCount = copy_src.correlationMaskCount;
pCorrelationMasks = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewMasks) {
pViewMasks = new uint32_t[copy_src.subpassCount];
memcpy ((void *)pViewMasks, (void *)copy_src.pViewMasks, sizeof(uint32_t)*copy_src.subpassCount);
}
if (copy_src.pViewOffsets) {
pViewOffsets = new int32_t[copy_src.dependencyCount];
memcpy ((void *)pViewOffsets, (void *)copy_src.pViewOffsets, sizeof(int32_t)*copy_src.dependencyCount);
}
if (copy_src.pCorrelationMasks) {
pCorrelationMasks = new uint32_t[copy_src.correlationMaskCount];
memcpy ((void *)pCorrelationMasks, (void *)copy_src.pCorrelationMasks, sizeof(uint32_t)*copy_src.correlationMaskCount);
}
return *this;
}
safe_VkRenderPassMultiviewCreateInfo::~safe_VkRenderPassMultiviewCreateInfo()
{
if (pViewMasks)
delete[] pViewMasks;
if (pViewOffsets)
delete[] pViewOffsets;
if (pCorrelationMasks)
delete[] pCorrelationMasks;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassMultiviewCreateInfo::initialize(const VkRenderPassMultiviewCreateInfo* in_struct)
{
sType = in_struct->sType;
subpassCount = in_struct->subpassCount;
pViewMasks = nullptr;
dependencyCount = in_struct->dependencyCount;
pViewOffsets = nullptr;
correlationMaskCount = in_struct->correlationMaskCount;
pCorrelationMasks = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewMasks) {
pViewMasks = new uint32_t[in_struct->subpassCount];
memcpy ((void *)pViewMasks, (void *)in_struct->pViewMasks, sizeof(uint32_t)*in_struct->subpassCount);
}
if (in_struct->pViewOffsets) {
pViewOffsets = new int32_t[in_struct->dependencyCount];
memcpy ((void *)pViewOffsets, (void *)in_struct->pViewOffsets, sizeof(int32_t)*in_struct->dependencyCount);
}
if (in_struct->pCorrelationMasks) {
pCorrelationMasks = new uint32_t[in_struct->correlationMaskCount];
memcpy ((void *)pCorrelationMasks, (void *)in_struct->pCorrelationMasks, sizeof(uint32_t)*in_struct->correlationMaskCount);
}
}
void safe_VkRenderPassMultiviewCreateInfo::initialize(const safe_VkRenderPassMultiviewCreateInfo* copy_src)
{
sType = copy_src->sType;
subpassCount = copy_src->subpassCount;
pViewMasks = nullptr;
dependencyCount = copy_src->dependencyCount;
pViewOffsets = nullptr;
correlationMaskCount = copy_src->correlationMaskCount;
pCorrelationMasks = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pViewMasks) {
pViewMasks = new uint32_t[copy_src->subpassCount];
memcpy ((void *)pViewMasks, (void *)copy_src->pViewMasks, sizeof(uint32_t)*copy_src->subpassCount);
}
if (copy_src->pViewOffsets) {
pViewOffsets = new int32_t[copy_src->dependencyCount];
memcpy ((void *)pViewOffsets, (void *)copy_src->pViewOffsets, sizeof(int32_t)*copy_src->dependencyCount);
}
if (copy_src->pCorrelationMasks) {
pCorrelationMasks = new uint32_t[copy_src->correlationMaskCount];
memcpy ((void *)pCorrelationMasks, (void *)copy_src->pCorrelationMasks, sizeof(uint32_t)*copy_src->correlationMaskCount);
}
}
safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct) :
sType(in_struct->sType),
multiview(in_struct->multiview),
multiviewGeometryShader(in_struct->multiviewGeometryShader),
multiviewTessellationShader(in_struct->multiviewTessellationShader)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src)
{
sType = copy_src.sType;
multiview = copy_src.multiview;
multiviewGeometryShader = copy_src.multiviewGeometryShader;
multiviewTessellationShader = copy_src.multiviewTessellationShader;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceMultiviewFeatures& safe_VkPhysicalDeviceMultiviewFeatures::operator=(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
multiview = copy_src.multiview;
multiviewGeometryShader = copy_src.multiviewGeometryShader;
multiviewTessellationShader = copy_src.multiviewTessellationShader;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceMultiviewFeatures::~safe_VkPhysicalDeviceMultiviewFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMultiviewFeatures::initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct)
{
sType = in_struct->sType;
multiview = in_struct->multiview;
multiviewGeometryShader = in_struct->multiviewGeometryShader;
multiviewTessellationShader = in_struct->multiviewTessellationShader;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceMultiviewFeatures::initialize(const safe_VkPhysicalDeviceMultiviewFeatures* copy_src)
{
sType = copy_src->sType;
multiview = copy_src->multiview;
multiviewGeometryShader = copy_src->multiviewGeometryShader;
multiviewTessellationShader = copy_src->multiviewTessellationShader;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct) :
sType(in_struct->sType),
maxMultiviewViewCount(in_struct->maxMultiviewViewCount),
maxMultiviewInstanceIndex(in_struct->maxMultiviewInstanceIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties(const safe_VkPhysicalDeviceMultiviewProperties& copy_src)
{
sType = copy_src.sType;
maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceMultiviewProperties& safe_VkPhysicalDeviceMultiviewProperties::operator=(const safe_VkPhysicalDeviceMultiviewProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceMultiviewProperties::~safe_VkPhysicalDeviceMultiviewProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMultiviewProperties::initialize(const VkPhysicalDeviceMultiviewProperties* in_struct)
{
sType = in_struct->sType;
maxMultiviewViewCount = in_struct->maxMultiviewViewCount;
maxMultiviewInstanceIndex = in_struct->maxMultiviewInstanceIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceMultiviewProperties::initialize(const safe_VkPhysicalDeviceMultiviewProperties* copy_src)
{
sType = copy_src->sType;
maxMultiviewViewCount = copy_src->maxMultiviewViewCount;
maxMultiviewInstanceIndex = copy_src->maxMultiviewInstanceIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct) :
sType(in_struct->sType),
variablePointersStorageBuffer(in_struct->variablePointersStorageBuffer),
variablePointers(in_struct->variablePointers)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src)
{
sType = copy_src.sType;
variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
variablePointers = copy_src.variablePointers;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceVariablePointersFeatures& safe_VkPhysicalDeviceVariablePointersFeatures::operator=(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
variablePointers = copy_src.variablePointers;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceVariablePointersFeatures::~safe_VkPhysicalDeviceVariablePointersFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVariablePointersFeatures::initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct)
{
sType = in_struct->sType;
variablePointersStorageBuffer = in_struct->variablePointersStorageBuffer;
variablePointers = in_struct->variablePointers;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceVariablePointersFeatures::initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* copy_src)
{
sType = copy_src->sType;
variablePointersStorageBuffer = copy_src->variablePointersStorageBuffer;
variablePointers = copy_src->variablePointers;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct) :
sType(in_struct->sType),
protectedMemory(in_struct->protectedMemory)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src)
{
sType = copy_src.sType;
protectedMemory = copy_src.protectedMemory;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceProtectedMemoryFeatures& safe_VkPhysicalDeviceProtectedMemoryFeatures::operator=(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
protectedMemory = copy_src.protectedMemory;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceProtectedMemoryFeatures::~safe_VkPhysicalDeviceProtectedMemoryFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceProtectedMemoryFeatures::initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct)
{
sType = in_struct->sType;
protectedMemory = in_struct->protectedMemory;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceProtectedMemoryFeatures::initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* copy_src)
{
sType = copy_src->sType;
protectedMemory = copy_src->protectedMemory;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct) :
sType(in_struct->sType),
protectedNoFault(in_struct->protectedNoFault)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src)
{
sType = copy_src.sType;
protectedNoFault = copy_src.protectedNoFault;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceProtectedMemoryProperties& safe_VkPhysicalDeviceProtectedMemoryProperties::operator=(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
protectedNoFault = copy_src.protectedNoFault;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceProtectedMemoryProperties::~safe_VkPhysicalDeviceProtectedMemoryProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceProtectedMemoryProperties::initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct)
{
sType = in_struct->sType;
protectedNoFault = in_struct->protectedNoFault;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceProtectedMemoryProperties::initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* copy_src)
{
sType = copy_src->sType;
protectedNoFault = copy_src->protectedNoFault;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
queueFamilyIndex(in_struct->queueFamilyIndex),
queueIndex(in_struct->queueIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2() :
sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2),
pNext(nullptr)
{}
safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
queueFamilyIndex = copy_src.queueFamilyIndex;
queueIndex = copy_src.queueIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceQueueInfo2& safe_VkDeviceQueueInfo2::operator=(const safe_VkDeviceQueueInfo2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
queueFamilyIndex = copy_src.queueFamilyIndex;
queueIndex = copy_src.queueIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceQueueInfo2::~safe_VkDeviceQueueInfo2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceQueueInfo2::initialize(const VkDeviceQueueInfo2* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
queueFamilyIndex = in_struct->queueFamilyIndex;
queueIndex = in_struct->queueIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceQueueInfo2::initialize(const safe_VkDeviceQueueInfo2* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
queueFamilyIndex = copy_src->queueFamilyIndex;
queueIndex = copy_src->queueIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct) :
sType(in_struct->sType),
protectedSubmit(in_struct->protectedSubmit)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo() :
sType(VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO),
pNext(nullptr)
{}
safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& copy_src)
{
sType = copy_src.sType;
protectedSubmit = copy_src.protectedSubmit;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkProtectedSubmitInfo& safe_VkProtectedSubmitInfo::operator=(const safe_VkProtectedSubmitInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
protectedSubmit = copy_src.protectedSubmit;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkProtectedSubmitInfo::~safe_VkProtectedSubmitInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkProtectedSubmitInfo::initialize(const VkProtectedSubmitInfo* in_struct)
{
sType = in_struct->sType;
protectedSubmit = in_struct->protectedSubmit;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkProtectedSubmitInfo::initialize(const safe_VkProtectedSubmitInfo* copy_src)
{
sType = copy_src->sType;
protectedSubmit = copy_src->protectedSubmit;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct) :
sType(in_struct->sType),
format(in_struct->format),
ycbcrModel(in_struct->ycbcrModel),
ycbcrRange(in_struct->ycbcrRange),
components(in_struct->components),
xChromaOffset(in_struct->xChromaOffset),
yChromaOffset(in_struct->yChromaOffset),
chromaFilter(in_struct->chromaFilter),
forceExplicitReconstruction(in_struct->forceExplicitReconstruction)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo() :
sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO),
pNext(nullptr)
{}
safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src)
{
sType = copy_src.sType;
format = copy_src.format;
ycbcrModel = copy_src.ycbcrModel;
ycbcrRange = copy_src.ycbcrRange;
components = copy_src.components;
xChromaOffset = copy_src.xChromaOffset;
yChromaOffset = copy_src.yChromaOffset;
chromaFilter = copy_src.chromaFilter;
forceExplicitReconstruction = copy_src.forceExplicitReconstruction;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSamplerYcbcrConversionCreateInfo& safe_VkSamplerYcbcrConversionCreateInfo::operator=(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
format = copy_src.format;
ycbcrModel = copy_src.ycbcrModel;
ycbcrRange = copy_src.ycbcrRange;
components = copy_src.components;
xChromaOffset = copy_src.xChromaOffset;
yChromaOffset = copy_src.yChromaOffset;
chromaFilter = copy_src.chromaFilter;
forceExplicitReconstruction = copy_src.forceExplicitReconstruction;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSamplerYcbcrConversionCreateInfo::~safe_VkSamplerYcbcrConversionCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct)
{
sType = in_struct->sType;
format = in_struct->format;
ycbcrModel = in_struct->ycbcrModel;
ycbcrRange = in_struct->ycbcrRange;
components = in_struct->components;
xChromaOffset = in_struct->xChromaOffset;
yChromaOffset = in_struct->yChromaOffset;
chromaFilter = in_struct->chromaFilter;
forceExplicitReconstruction = in_struct->forceExplicitReconstruction;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const safe_VkSamplerYcbcrConversionCreateInfo* copy_src)
{
sType = copy_src->sType;
format = copy_src->format;
ycbcrModel = copy_src->ycbcrModel;
ycbcrRange = copy_src->ycbcrRange;
components = copy_src->components;
xChromaOffset = copy_src->xChromaOffset;
yChromaOffset = copy_src->yChromaOffset;
chromaFilter = copy_src->chromaFilter;
forceExplicitReconstruction = copy_src->forceExplicitReconstruction;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct) :
sType(in_struct->sType),
conversion(in_struct->conversion)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo() :
sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO),
pNext(nullptr)
{}
safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& copy_src)
{
sType = copy_src.sType;
conversion = copy_src.conversion;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSamplerYcbcrConversionInfo& safe_VkSamplerYcbcrConversionInfo::operator=(const safe_VkSamplerYcbcrConversionInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
conversion = copy_src.conversion;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSamplerYcbcrConversionInfo::~safe_VkSamplerYcbcrConversionInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSamplerYcbcrConversionInfo::initialize(const VkSamplerYcbcrConversionInfo* in_struct)
{
sType = in_struct->sType;
conversion = in_struct->conversion;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSamplerYcbcrConversionInfo::initialize(const safe_VkSamplerYcbcrConversionInfo* copy_src)
{
sType = copy_src->sType;
conversion = copy_src->conversion;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct) :
sType(in_struct->sType),
planeAspect(in_struct->planeAspect)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo() :
sType(VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO),
pNext(nullptr)
{}
safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& copy_src)
{
sType = copy_src.sType;
planeAspect = copy_src.planeAspect;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBindImagePlaneMemoryInfo& safe_VkBindImagePlaneMemoryInfo::operator=(const safe_VkBindImagePlaneMemoryInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
planeAspect = copy_src.planeAspect;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBindImagePlaneMemoryInfo::~safe_VkBindImagePlaneMemoryInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBindImagePlaneMemoryInfo::initialize(const VkBindImagePlaneMemoryInfo* in_struct)
{
sType = in_struct->sType;
planeAspect = in_struct->planeAspect;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBindImagePlaneMemoryInfo::initialize(const safe_VkBindImagePlaneMemoryInfo* copy_src)
{
sType = copy_src->sType;
planeAspect = copy_src->planeAspect;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct) :
sType(in_struct->sType),
planeAspect(in_struct->planeAspect)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo() :
sType(VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO),
pNext(nullptr)
{}
safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src)
{
sType = copy_src.sType;
planeAspect = copy_src.planeAspect;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImagePlaneMemoryRequirementsInfo& safe_VkImagePlaneMemoryRequirementsInfo::operator=(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
planeAspect = copy_src.planeAspect;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImagePlaneMemoryRequirementsInfo::~safe_VkImagePlaneMemoryRequirementsInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImagePlaneMemoryRequirementsInfo::initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct)
{
sType = in_struct->sType;
planeAspect = in_struct->planeAspect;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImagePlaneMemoryRequirementsInfo::initialize(const safe_VkImagePlaneMemoryRequirementsInfo* copy_src)
{
sType = copy_src->sType;
planeAspect = copy_src->planeAspect;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct) :
sType(in_struct->sType),
samplerYcbcrConversion(in_struct->samplerYcbcrConversion)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src)
{
sType = copy_src.sType;
samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::operator=(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct)
{
sType = in_struct->sType;
samplerYcbcrConversion = in_struct->samplerYcbcrConversion;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::initialize(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* copy_src)
{
sType = copy_src->sType;
samplerYcbcrConversion = copy_src->samplerYcbcrConversion;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct) :
sType(in_struct->sType),
combinedImageSamplerDescriptorCount(in_struct->combinedImageSamplerDescriptorCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties() :
sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES),
pNext(nullptr)
{}
safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties(const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src)
{
sType = copy_src.sType;
combinedImageSamplerDescriptorCount = copy_src.combinedImageSamplerDescriptorCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSamplerYcbcrConversionImageFormatProperties& safe_VkSamplerYcbcrConversionImageFormatProperties::operator=(const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
combinedImageSamplerDescriptorCount = copy_src.combinedImageSamplerDescriptorCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSamplerYcbcrConversionImageFormatProperties::~safe_VkSamplerYcbcrConversionImageFormatProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSamplerYcbcrConversionImageFormatProperties::initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct)
{
sType = in_struct->sType;
combinedImageSamplerDescriptorCount = in_struct->combinedImageSamplerDescriptorCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSamplerYcbcrConversionImageFormatProperties::initialize(const safe_VkSamplerYcbcrConversionImageFormatProperties* copy_src)
{
sType = copy_src->sType;
combinedImageSamplerDescriptorCount = copy_src->combinedImageSamplerDescriptorCount;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
descriptorUpdateEntryCount(in_struct->descriptorUpdateEntryCount),
pDescriptorUpdateEntries(nullptr),
templateType(in_struct->templateType),
descriptorSetLayout(in_struct->descriptorSetLayout),
pipelineBindPoint(in_struct->pipelineBindPoint),
pipelineLayout(in_struct->pipelineLayout),
set(in_struct->set)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDescriptorUpdateEntries) {
pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[in_struct->descriptorUpdateEntryCount];
memcpy ((void *)pDescriptorUpdateEntries, (void *)in_struct->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*in_struct->descriptorUpdateEntryCount);
}
}
safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO),
pNext(nullptr),
pDescriptorUpdateEntries(nullptr)
{}
safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
descriptorUpdateEntryCount = copy_src.descriptorUpdateEntryCount;
pDescriptorUpdateEntries = nullptr;
templateType = copy_src.templateType;
descriptorSetLayout = copy_src.descriptorSetLayout;
pipelineBindPoint = copy_src.pipelineBindPoint;
pipelineLayout = copy_src.pipelineLayout;
set = copy_src.set;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDescriptorUpdateEntries) {
pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src.descriptorUpdateEntryCount];
memcpy ((void *)pDescriptorUpdateEntries, (void *)copy_src.pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*copy_src.descriptorUpdateEntryCount);
}
}
safe_VkDescriptorUpdateTemplateCreateInfo& safe_VkDescriptorUpdateTemplateCreateInfo::operator=(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pDescriptorUpdateEntries)
delete[] pDescriptorUpdateEntries;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
descriptorUpdateEntryCount = copy_src.descriptorUpdateEntryCount;
pDescriptorUpdateEntries = nullptr;
templateType = copy_src.templateType;
descriptorSetLayout = copy_src.descriptorSetLayout;
pipelineBindPoint = copy_src.pipelineBindPoint;
pipelineLayout = copy_src.pipelineLayout;
set = copy_src.set;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDescriptorUpdateEntries) {
pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src.descriptorUpdateEntryCount];
memcpy ((void *)pDescriptorUpdateEntries, (void *)copy_src.pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*copy_src.descriptorUpdateEntryCount);
}
return *this;
}
safe_VkDescriptorUpdateTemplateCreateInfo::~safe_VkDescriptorUpdateTemplateCreateInfo()
{
if (pDescriptorUpdateEntries)
delete[] pDescriptorUpdateEntries;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
descriptorUpdateEntryCount = in_struct->descriptorUpdateEntryCount;
pDescriptorUpdateEntries = nullptr;
templateType = in_struct->templateType;
descriptorSetLayout = in_struct->descriptorSetLayout;
pipelineBindPoint = in_struct->pipelineBindPoint;
pipelineLayout = in_struct->pipelineLayout;
set = in_struct->set;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDescriptorUpdateEntries) {
pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[in_struct->descriptorUpdateEntryCount];
memcpy ((void *)pDescriptorUpdateEntries, (void *)in_struct->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*in_struct->descriptorUpdateEntryCount);
}
}
void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
descriptorUpdateEntryCount = copy_src->descriptorUpdateEntryCount;
pDescriptorUpdateEntries = nullptr;
templateType = copy_src->templateType;
descriptorSetLayout = copy_src->descriptorSetLayout;
pipelineBindPoint = copy_src->pipelineBindPoint;
pipelineLayout = copy_src->pipelineLayout;
set = copy_src->set;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDescriptorUpdateEntries) {
pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src->descriptorUpdateEntryCount];
memcpy ((void *)pDescriptorUpdateEntries, (void *)copy_src->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*copy_src->descriptorUpdateEntryCount);
}
}
safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct) :
sType(in_struct->sType),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO),
pNext(nullptr)
{}
safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src)
{
sType = copy_src.sType;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExternalImageFormatInfo& safe_VkPhysicalDeviceExternalImageFormatInfo::operator=(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExternalImageFormatInfo::~safe_VkPhysicalDeviceExternalImageFormatInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExternalImageFormatInfo::initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct)
{
sType = in_struct->sType;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceExternalImageFormatInfo::initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* copy_src)
{
sType = copy_src->sType;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct) :
sType(in_struct->sType),
externalMemoryProperties(in_struct->externalMemoryProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties() :
sType(VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES),
pNext(nullptr)
{}
safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& copy_src)
{
sType = copy_src.sType;
externalMemoryProperties = copy_src.externalMemoryProperties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalImageFormatProperties& safe_VkExternalImageFormatProperties::operator=(const safe_VkExternalImageFormatProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
externalMemoryProperties = copy_src.externalMemoryProperties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalImageFormatProperties::~safe_VkExternalImageFormatProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExternalImageFormatProperties::initialize(const VkExternalImageFormatProperties* in_struct)
{
sType = in_struct->sType;
externalMemoryProperties = in_struct->externalMemoryProperties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExternalImageFormatProperties::initialize(const safe_VkExternalImageFormatProperties* copy_src)
{
sType = copy_src->sType;
externalMemoryProperties = copy_src->externalMemoryProperties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
usage(in_struct->usage),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO),
pNext(nullptr)
{}
safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
usage = copy_src.usage;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExternalBufferInfo& safe_VkPhysicalDeviceExternalBufferInfo::operator=(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
usage = copy_src.usage;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExternalBufferInfo::~safe_VkPhysicalDeviceExternalBufferInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExternalBufferInfo::initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
usage = in_struct->usage;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceExternalBufferInfo::initialize(const safe_VkPhysicalDeviceExternalBufferInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
usage = copy_src->usage;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalBufferProperties::safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct) :
sType(in_struct->sType),
externalMemoryProperties(in_struct->externalMemoryProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExternalBufferProperties::safe_VkExternalBufferProperties() :
sType(VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES),
pNext(nullptr)
{}
safe_VkExternalBufferProperties::safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& copy_src)
{
sType = copy_src.sType;
externalMemoryProperties = copy_src.externalMemoryProperties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalBufferProperties& safe_VkExternalBufferProperties::operator=(const safe_VkExternalBufferProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
externalMemoryProperties = copy_src.externalMemoryProperties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalBufferProperties::~safe_VkExternalBufferProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExternalBufferProperties::initialize(const VkExternalBufferProperties* in_struct)
{
sType = in_struct->sType;
externalMemoryProperties = in_struct->externalMemoryProperties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExternalBufferProperties::initialize(const safe_VkExternalBufferProperties* copy_src)
{
sType = copy_src->sType;
externalMemoryProperties = copy_src->externalMemoryProperties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct) :
sType(in_struct->sType),
deviceNodeMask(in_struct->deviceNodeMask),
deviceLUIDValid(in_struct->deviceLUIDValid)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = in_struct->deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = in_struct->driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = in_struct->deviceLUID[i];
}
}
safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& copy_src)
{
sType = copy_src.sType;
deviceNodeMask = copy_src.deviceNodeMask;
deviceLUIDValid = copy_src.deviceLUIDValid;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = copy_src.deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = copy_src.driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = copy_src.deviceLUID[i];
}
}
safe_VkPhysicalDeviceIDProperties& safe_VkPhysicalDeviceIDProperties::operator=(const safe_VkPhysicalDeviceIDProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceNodeMask = copy_src.deviceNodeMask;
deviceLUIDValid = copy_src.deviceLUIDValid;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = copy_src.deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = copy_src.driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = copy_src.deviceLUID[i];
}
return *this;
}
safe_VkPhysicalDeviceIDProperties::~safe_VkPhysicalDeviceIDProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceIDProperties::initialize(const VkPhysicalDeviceIDProperties* in_struct)
{
sType = in_struct->sType;
deviceNodeMask = in_struct->deviceNodeMask;
deviceLUIDValid = in_struct->deviceLUIDValid;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = in_struct->deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = in_struct->driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = in_struct->deviceLUID[i];
}
}
void safe_VkPhysicalDeviceIDProperties::initialize(const safe_VkPhysicalDeviceIDProperties* copy_src)
{
sType = copy_src->sType;
deviceNodeMask = copy_src->deviceNodeMask;
deviceLUIDValid = copy_src->deviceLUIDValid;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = copy_src->deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = copy_src->driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = copy_src->deviceLUID[i];
}
}
safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct) :
sType(in_struct->sType),
handleTypes(in_struct->handleTypes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo() :
sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& copy_src)
{
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalMemoryImageCreateInfo& safe_VkExternalMemoryImageCreateInfo::operator=(const safe_VkExternalMemoryImageCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalMemoryImageCreateInfo::~safe_VkExternalMemoryImageCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExternalMemoryImageCreateInfo::initialize(const VkExternalMemoryImageCreateInfo* in_struct)
{
sType = in_struct->sType;
handleTypes = in_struct->handleTypes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExternalMemoryImageCreateInfo::initialize(const safe_VkExternalMemoryImageCreateInfo* copy_src)
{
sType = copy_src->sType;
handleTypes = copy_src->handleTypes;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct) :
sType(in_struct->sType),
handleTypes(in_struct->handleTypes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo() :
sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO),
pNext(nullptr)
{}
safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo(const safe_VkExternalMemoryBufferCreateInfo& copy_src)
{
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalMemoryBufferCreateInfo& safe_VkExternalMemoryBufferCreateInfo::operator=(const safe_VkExternalMemoryBufferCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalMemoryBufferCreateInfo::~safe_VkExternalMemoryBufferCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExternalMemoryBufferCreateInfo::initialize(const VkExternalMemoryBufferCreateInfo* in_struct)
{
sType = in_struct->sType;
handleTypes = in_struct->handleTypes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExternalMemoryBufferCreateInfo::initialize(const safe_VkExternalMemoryBufferCreateInfo* copy_src)
{
sType = copy_src->sType;
handleTypes = copy_src->handleTypes;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct) :
sType(in_struct->sType),
handleTypes(in_struct->handleTypes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo() :
sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO),
pNext(nullptr)
{}
safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& copy_src)
{
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExportMemoryAllocateInfo& safe_VkExportMemoryAllocateInfo::operator=(const safe_VkExportMemoryAllocateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExportMemoryAllocateInfo::~safe_VkExportMemoryAllocateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExportMemoryAllocateInfo::initialize(const VkExportMemoryAllocateInfo* in_struct)
{
sType = in_struct->sType;
handleTypes = in_struct->handleTypes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExportMemoryAllocateInfo::initialize(const safe_VkExportMemoryAllocateInfo* copy_src)
{
sType = copy_src->sType;
handleTypes = copy_src->handleTypes;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct) :
sType(in_struct->sType),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO),
pNext(nullptr)
{}
safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src)
{
sType = copy_src.sType;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExternalFenceInfo& safe_VkPhysicalDeviceExternalFenceInfo::operator=(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExternalFenceInfo::~safe_VkPhysicalDeviceExternalFenceInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExternalFenceInfo::initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct)
{
sType = in_struct->sType;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceExternalFenceInfo::initialize(const safe_VkPhysicalDeviceExternalFenceInfo* copy_src)
{
sType = copy_src->sType;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalFenceProperties::safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct) :
sType(in_struct->sType),
exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes),
compatibleHandleTypes(in_struct->compatibleHandleTypes),
externalFenceFeatures(in_struct->externalFenceFeatures)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExternalFenceProperties::safe_VkExternalFenceProperties() :
sType(VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES),
pNext(nullptr)
{}
safe_VkExternalFenceProperties::safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& copy_src)
{
sType = copy_src.sType;
exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
compatibleHandleTypes = copy_src.compatibleHandleTypes;
externalFenceFeatures = copy_src.externalFenceFeatures;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalFenceProperties& safe_VkExternalFenceProperties::operator=(const safe_VkExternalFenceProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
compatibleHandleTypes = copy_src.compatibleHandleTypes;
externalFenceFeatures = copy_src.externalFenceFeatures;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalFenceProperties::~safe_VkExternalFenceProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExternalFenceProperties::initialize(const VkExternalFenceProperties* in_struct)
{
sType = in_struct->sType;
exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes;
compatibleHandleTypes = in_struct->compatibleHandleTypes;
externalFenceFeatures = in_struct->externalFenceFeatures;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExternalFenceProperties::initialize(const safe_VkExternalFenceProperties* copy_src)
{
sType = copy_src->sType;
exportFromImportedHandleTypes = copy_src->exportFromImportedHandleTypes;
compatibleHandleTypes = copy_src->compatibleHandleTypes;
externalFenceFeatures = copy_src->externalFenceFeatures;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct) :
sType(in_struct->sType),
handleTypes(in_struct->handleTypes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo() :
sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& copy_src)
{
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExportFenceCreateInfo& safe_VkExportFenceCreateInfo::operator=(const safe_VkExportFenceCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExportFenceCreateInfo::~safe_VkExportFenceCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExportFenceCreateInfo::initialize(const VkExportFenceCreateInfo* in_struct)
{
sType = in_struct->sType;
handleTypes = in_struct->handleTypes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExportFenceCreateInfo::initialize(const safe_VkExportFenceCreateInfo* copy_src)
{
sType = copy_src->sType;
handleTypes = copy_src->handleTypes;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct) :
sType(in_struct->sType),
handleTypes(in_struct->handleTypes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo() :
sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& copy_src)
{
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExportSemaphoreCreateInfo& safe_VkExportSemaphoreCreateInfo::operator=(const safe_VkExportSemaphoreCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExportSemaphoreCreateInfo::~safe_VkExportSemaphoreCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExportSemaphoreCreateInfo::initialize(const VkExportSemaphoreCreateInfo* in_struct)
{
sType = in_struct->sType;
handleTypes = in_struct->handleTypes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExportSemaphoreCreateInfo::initialize(const safe_VkExportSemaphoreCreateInfo* copy_src)
{
sType = copy_src->sType;
handleTypes = copy_src->handleTypes;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct) :
sType(in_struct->sType),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO),
pNext(nullptr)
{}
safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src)
{
sType = copy_src.sType;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExternalSemaphoreInfo& safe_VkPhysicalDeviceExternalSemaphoreInfo::operator=(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExternalSemaphoreInfo::~safe_VkPhysicalDeviceExternalSemaphoreInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExternalSemaphoreInfo::initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct)
{
sType = in_struct->sType;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceExternalSemaphoreInfo::initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* copy_src)
{
sType = copy_src->sType;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct) :
sType(in_struct->sType),
exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes),
compatibleHandleTypes(in_struct->compatibleHandleTypes),
externalSemaphoreFeatures(in_struct->externalSemaphoreFeatures)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties() :
sType(VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES),
pNext(nullptr)
{}
safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& copy_src)
{
sType = copy_src.sType;
exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
compatibleHandleTypes = copy_src.compatibleHandleTypes;
externalSemaphoreFeatures = copy_src.externalSemaphoreFeatures;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalSemaphoreProperties& safe_VkExternalSemaphoreProperties::operator=(const safe_VkExternalSemaphoreProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
compatibleHandleTypes = copy_src.compatibleHandleTypes;
externalSemaphoreFeatures = copy_src.externalSemaphoreFeatures;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalSemaphoreProperties::~safe_VkExternalSemaphoreProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExternalSemaphoreProperties::initialize(const VkExternalSemaphoreProperties* in_struct)
{
sType = in_struct->sType;
exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes;
compatibleHandleTypes = in_struct->compatibleHandleTypes;
externalSemaphoreFeatures = in_struct->externalSemaphoreFeatures;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExternalSemaphoreProperties::initialize(const safe_VkExternalSemaphoreProperties* copy_src)
{
sType = copy_src->sType;
exportFromImportedHandleTypes = copy_src->exportFromImportedHandleTypes;
compatibleHandleTypes = copy_src->compatibleHandleTypes;
externalSemaphoreFeatures = copy_src->externalSemaphoreFeatures;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct) :
sType(in_struct->sType),
maxPerSetDescriptors(in_struct->maxPerSetDescriptors),
maxMemoryAllocationSize(in_struct->maxMemoryAllocationSize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src)
{
sType = copy_src.sType;
maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceMaintenance3Properties& safe_VkPhysicalDeviceMaintenance3Properties::operator=(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceMaintenance3Properties::~safe_VkPhysicalDeviceMaintenance3Properties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMaintenance3Properties::initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct)
{
sType = in_struct->sType;
maxPerSetDescriptors = in_struct->maxPerSetDescriptors;
maxMemoryAllocationSize = in_struct->maxMemoryAllocationSize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceMaintenance3Properties::initialize(const safe_VkPhysicalDeviceMaintenance3Properties* copy_src)
{
sType = copy_src->sType;
maxPerSetDescriptors = copy_src->maxPerSetDescriptors;
maxMemoryAllocationSize = copy_src->maxMemoryAllocationSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct) :
sType(in_struct->sType),
supported(in_struct->supported)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT),
pNext(nullptr)
{}
safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& copy_src)
{
sType = copy_src.sType;
supported = copy_src.supported;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDescriptorSetLayoutSupport& safe_VkDescriptorSetLayoutSupport::operator=(const safe_VkDescriptorSetLayoutSupport& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
supported = copy_src.supported;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDescriptorSetLayoutSupport::~safe_VkDescriptorSetLayoutSupport()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorSetLayoutSupport::initialize(const VkDescriptorSetLayoutSupport* in_struct)
{
sType = in_struct->sType;
supported = in_struct->supported;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDescriptorSetLayoutSupport::initialize(const safe_VkDescriptorSetLayoutSupport* copy_src)
{
sType = copy_src->sType;
supported = copy_src->supported;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct) :
sType(in_struct->sType),
shaderDrawParameters(in_struct->shaderDrawParameters)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src)
{
sType = copy_src.sType;
shaderDrawParameters = copy_src.shaderDrawParameters;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderDrawParametersFeatures& safe_VkPhysicalDeviceShaderDrawParametersFeatures::operator=(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderDrawParameters = copy_src.shaderDrawParameters;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderDrawParametersFeatures::~safe_VkPhysicalDeviceShaderDrawParametersFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct)
{
sType = in_struct->sType;
shaderDrawParameters = in_struct->shaderDrawParameters;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize(const safe_VkPhysicalDeviceShaderDrawParametersFeatures* copy_src)
{
sType = copy_src->sType;
shaderDrawParameters = copy_src->shaderDrawParameters;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct) :
sType(in_struct->sType),
storageBuffer16BitAccess(in_struct->storageBuffer16BitAccess),
uniformAndStorageBuffer16BitAccess(in_struct->uniformAndStorageBuffer16BitAccess),
storagePushConstant16(in_struct->storagePushConstant16),
storageInputOutput16(in_struct->storageInputOutput16),
multiview(in_struct->multiview),
multiviewGeometryShader(in_struct->multiviewGeometryShader),
multiviewTessellationShader(in_struct->multiviewTessellationShader),
variablePointersStorageBuffer(in_struct->variablePointersStorageBuffer),
variablePointers(in_struct->variablePointers),
protectedMemory(in_struct->protectedMemory),
samplerYcbcrConversion(in_struct->samplerYcbcrConversion),
shaderDrawParameters(in_struct->shaderDrawParameters)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features(const safe_VkPhysicalDeviceVulkan11Features& copy_src)
{
sType = copy_src.sType;
storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess;
uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess;
storagePushConstant16 = copy_src.storagePushConstant16;
storageInputOutput16 = copy_src.storageInputOutput16;
multiview = copy_src.multiview;
multiviewGeometryShader = copy_src.multiviewGeometryShader;
multiviewTessellationShader = copy_src.multiviewTessellationShader;
variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
variablePointers = copy_src.variablePointers;
protectedMemory = copy_src.protectedMemory;
samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
shaderDrawParameters = copy_src.shaderDrawParameters;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceVulkan11Features& safe_VkPhysicalDeviceVulkan11Features::operator=(const safe_VkPhysicalDeviceVulkan11Features& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess;
uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess;
storagePushConstant16 = copy_src.storagePushConstant16;
storageInputOutput16 = copy_src.storageInputOutput16;
multiview = copy_src.multiview;
multiviewGeometryShader = copy_src.multiviewGeometryShader;
multiviewTessellationShader = copy_src.multiviewTessellationShader;
variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
variablePointers = copy_src.variablePointers;
protectedMemory = copy_src.protectedMemory;
samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
shaderDrawParameters = copy_src.shaderDrawParameters;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceVulkan11Features::~safe_VkPhysicalDeviceVulkan11Features()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVulkan11Features::initialize(const VkPhysicalDeviceVulkan11Features* in_struct)
{
sType = in_struct->sType;
storageBuffer16BitAccess = in_struct->storageBuffer16BitAccess;
uniformAndStorageBuffer16BitAccess = in_struct->uniformAndStorageBuffer16BitAccess;
storagePushConstant16 = in_struct->storagePushConstant16;
storageInputOutput16 = in_struct->storageInputOutput16;
multiview = in_struct->multiview;
multiviewGeometryShader = in_struct->multiviewGeometryShader;
multiviewTessellationShader = in_struct->multiviewTessellationShader;
variablePointersStorageBuffer = in_struct->variablePointersStorageBuffer;
variablePointers = in_struct->variablePointers;
protectedMemory = in_struct->protectedMemory;
samplerYcbcrConversion = in_struct->samplerYcbcrConversion;
shaderDrawParameters = in_struct->shaderDrawParameters;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceVulkan11Features::initialize(const safe_VkPhysicalDeviceVulkan11Features* copy_src)
{
sType = copy_src->sType;
storageBuffer16BitAccess = copy_src->storageBuffer16BitAccess;
uniformAndStorageBuffer16BitAccess = copy_src->uniformAndStorageBuffer16BitAccess;
storagePushConstant16 = copy_src->storagePushConstant16;
storageInputOutput16 = copy_src->storageInputOutput16;
multiview = copy_src->multiview;
multiviewGeometryShader = copy_src->multiviewGeometryShader;
multiviewTessellationShader = copy_src->multiviewTessellationShader;
variablePointersStorageBuffer = copy_src->variablePointersStorageBuffer;
variablePointers = copy_src->variablePointers;
protectedMemory = copy_src->protectedMemory;
samplerYcbcrConversion = copy_src->samplerYcbcrConversion;
shaderDrawParameters = copy_src->shaderDrawParameters;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties* in_struct) :
sType(in_struct->sType),
deviceNodeMask(in_struct->deviceNodeMask),
deviceLUIDValid(in_struct->deviceLUIDValid),
subgroupSize(in_struct->subgroupSize),
subgroupSupportedStages(in_struct->subgroupSupportedStages),
subgroupSupportedOperations(in_struct->subgroupSupportedOperations),
subgroupQuadOperationsInAllStages(in_struct->subgroupQuadOperationsInAllStages),
pointClippingBehavior(in_struct->pointClippingBehavior),
maxMultiviewViewCount(in_struct->maxMultiviewViewCount),
maxMultiviewInstanceIndex(in_struct->maxMultiviewInstanceIndex),
protectedNoFault(in_struct->protectedNoFault),
maxPerSetDescriptors(in_struct->maxPerSetDescriptors),
maxMemoryAllocationSize(in_struct->maxMemoryAllocationSize)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = in_struct->deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = in_struct->driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = in_struct->deviceLUID[i];
}
}
safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties(const safe_VkPhysicalDeviceVulkan11Properties& copy_src)
{
sType = copy_src.sType;
deviceNodeMask = copy_src.deviceNodeMask;
deviceLUIDValid = copy_src.deviceLUIDValid;
subgroupSize = copy_src.subgroupSize;
subgroupSupportedStages = copy_src.subgroupSupportedStages;
subgroupSupportedOperations = copy_src.subgroupSupportedOperations;
subgroupQuadOperationsInAllStages = copy_src.subgroupQuadOperationsInAllStages;
pointClippingBehavior = copy_src.pointClippingBehavior;
maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
protectedNoFault = copy_src.protectedNoFault;
maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = copy_src.deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = copy_src.driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = copy_src.deviceLUID[i];
}
}
safe_VkPhysicalDeviceVulkan11Properties& safe_VkPhysicalDeviceVulkan11Properties::operator=(const safe_VkPhysicalDeviceVulkan11Properties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceNodeMask = copy_src.deviceNodeMask;
deviceLUIDValid = copy_src.deviceLUIDValid;
subgroupSize = copy_src.subgroupSize;
subgroupSupportedStages = copy_src.subgroupSupportedStages;
subgroupSupportedOperations = copy_src.subgroupSupportedOperations;
subgroupQuadOperationsInAllStages = copy_src.subgroupQuadOperationsInAllStages;
pointClippingBehavior = copy_src.pointClippingBehavior;
maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
protectedNoFault = copy_src.protectedNoFault;
maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = copy_src.deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = copy_src.driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = copy_src.deviceLUID[i];
}
return *this;
}
safe_VkPhysicalDeviceVulkan11Properties::~safe_VkPhysicalDeviceVulkan11Properties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVulkan11Properties::initialize(const VkPhysicalDeviceVulkan11Properties* in_struct)
{
sType = in_struct->sType;
deviceNodeMask = in_struct->deviceNodeMask;
deviceLUIDValid = in_struct->deviceLUIDValid;
subgroupSize = in_struct->subgroupSize;
subgroupSupportedStages = in_struct->subgroupSupportedStages;
subgroupSupportedOperations = in_struct->subgroupSupportedOperations;
subgroupQuadOperationsInAllStages = in_struct->subgroupQuadOperationsInAllStages;
pointClippingBehavior = in_struct->pointClippingBehavior;
maxMultiviewViewCount = in_struct->maxMultiviewViewCount;
maxMultiviewInstanceIndex = in_struct->maxMultiviewInstanceIndex;
protectedNoFault = in_struct->protectedNoFault;
maxPerSetDescriptors = in_struct->maxPerSetDescriptors;
maxMemoryAllocationSize = in_struct->maxMemoryAllocationSize;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = in_struct->deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = in_struct->driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = in_struct->deviceLUID[i];
}
}
void safe_VkPhysicalDeviceVulkan11Properties::initialize(const safe_VkPhysicalDeviceVulkan11Properties* copy_src)
{
sType = copy_src->sType;
deviceNodeMask = copy_src->deviceNodeMask;
deviceLUIDValid = copy_src->deviceLUIDValid;
subgroupSize = copy_src->subgroupSize;
subgroupSupportedStages = copy_src->subgroupSupportedStages;
subgroupSupportedOperations = copy_src->subgroupSupportedOperations;
subgroupQuadOperationsInAllStages = copy_src->subgroupQuadOperationsInAllStages;
pointClippingBehavior = copy_src->pointClippingBehavior;
maxMultiviewViewCount = copy_src->maxMultiviewViewCount;
maxMultiviewInstanceIndex = copy_src->maxMultiviewInstanceIndex;
protectedNoFault = copy_src->protectedNoFault;
maxPerSetDescriptors = copy_src->maxPerSetDescriptors;
maxMemoryAllocationSize = copy_src->maxMemoryAllocationSize;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
deviceUUID[i] = copy_src->deviceUUID[i];
}
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
driverUUID[i] = copy_src->driverUUID[i];
}
for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
deviceLUID[i] = copy_src->deviceLUID[i];
}
}
safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* in_struct) :
sType(in_struct->sType),
samplerMirrorClampToEdge(in_struct->samplerMirrorClampToEdge),
drawIndirectCount(in_struct->drawIndirectCount),
storageBuffer8BitAccess(in_struct->storageBuffer8BitAccess),
uniformAndStorageBuffer8BitAccess(in_struct->uniformAndStorageBuffer8BitAccess),
storagePushConstant8(in_struct->storagePushConstant8),
shaderBufferInt64Atomics(in_struct->shaderBufferInt64Atomics),
shaderSharedInt64Atomics(in_struct->shaderSharedInt64Atomics),
shaderFloat16(in_struct->shaderFloat16),
shaderInt8(in_struct->shaderInt8),
descriptorIndexing(in_struct->descriptorIndexing),
shaderInputAttachmentArrayDynamicIndexing(in_struct->shaderInputAttachmentArrayDynamicIndexing),
shaderUniformTexelBufferArrayDynamicIndexing(in_struct->shaderUniformTexelBufferArrayDynamicIndexing),
shaderStorageTexelBufferArrayDynamicIndexing(in_struct->shaderStorageTexelBufferArrayDynamicIndexing),
shaderUniformBufferArrayNonUniformIndexing(in_struct->shaderUniformBufferArrayNonUniformIndexing),
shaderSampledImageArrayNonUniformIndexing(in_struct->shaderSampledImageArrayNonUniformIndexing),
shaderStorageBufferArrayNonUniformIndexing(in_struct->shaderStorageBufferArrayNonUniformIndexing),
shaderStorageImageArrayNonUniformIndexing(in_struct->shaderStorageImageArrayNonUniformIndexing),
shaderInputAttachmentArrayNonUniformIndexing(in_struct->shaderInputAttachmentArrayNonUniformIndexing),
shaderUniformTexelBufferArrayNonUniformIndexing(in_struct->shaderUniformTexelBufferArrayNonUniformIndexing),
shaderStorageTexelBufferArrayNonUniformIndexing(in_struct->shaderStorageTexelBufferArrayNonUniformIndexing),
descriptorBindingUniformBufferUpdateAfterBind(in_struct->descriptorBindingUniformBufferUpdateAfterBind),
descriptorBindingSampledImageUpdateAfterBind(in_struct->descriptorBindingSampledImageUpdateAfterBind),
descriptorBindingStorageImageUpdateAfterBind(in_struct->descriptorBindingStorageImageUpdateAfterBind),
descriptorBindingStorageBufferUpdateAfterBind(in_struct->descriptorBindingStorageBufferUpdateAfterBind),
descriptorBindingUniformTexelBufferUpdateAfterBind(in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind),
descriptorBindingStorageTexelBufferUpdateAfterBind(in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind),
descriptorBindingUpdateUnusedWhilePending(in_struct->descriptorBindingUpdateUnusedWhilePending),
descriptorBindingPartiallyBound(in_struct->descriptorBindingPartiallyBound),
descriptorBindingVariableDescriptorCount(in_struct->descriptorBindingVariableDescriptorCount),
runtimeDescriptorArray(in_struct->runtimeDescriptorArray),
samplerFilterMinmax(in_struct->samplerFilterMinmax),
scalarBlockLayout(in_struct->scalarBlockLayout),
imagelessFramebuffer(in_struct->imagelessFramebuffer),
uniformBufferStandardLayout(in_struct->uniformBufferStandardLayout),
shaderSubgroupExtendedTypes(in_struct->shaderSubgroupExtendedTypes),
separateDepthStencilLayouts(in_struct->separateDepthStencilLayouts),
hostQueryReset(in_struct->hostQueryReset),
timelineSemaphore(in_struct->timelineSemaphore),
bufferDeviceAddress(in_struct->bufferDeviceAddress),
bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay),
bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice),
vulkanMemoryModel(in_struct->vulkanMemoryModel),
vulkanMemoryModelDeviceScope(in_struct->vulkanMemoryModelDeviceScope),
vulkanMemoryModelAvailabilityVisibilityChains(in_struct->vulkanMemoryModelAvailabilityVisibilityChains),
shaderOutputViewportIndex(in_struct->shaderOutputViewportIndex),
shaderOutputLayer(in_struct->shaderOutputLayer),
subgroupBroadcastDynamicId(in_struct->subgroupBroadcastDynamicId)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features(const safe_VkPhysicalDeviceVulkan12Features& copy_src)
{
sType = copy_src.sType;
samplerMirrorClampToEdge = copy_src.samplerMirrorClampToEdge;
drawIndirectCount = copy_src.drawIndirectCount;
storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
storagePushConstant8 = copy_src.storagePushConstant8;
shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
shaderFloat16 = copy_src.shaderFloat16;
shaderInt8 = copy_src.shaderInt8;
descriptorIndexing = copy_src.descriptorIndexing;
shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing;
shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing;
shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing;
shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing;
shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing;
shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing;
shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing;
shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing;
shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing;
shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing;
descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind;
descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind;
descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind;
descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind;
descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind;
descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind;
descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending;
descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound;
descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount;
runtimeDescriptorArray = copy_src.runtimeDescriptorArray;
samplerFilterMinmax = copy_src.samplerFilterMinmax;
scalarBlockLayout = copy_src.scalarBlockLayout;
imagelessFramebuffer = copy_src.imagelessFramebuffer;
uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
hostQueryReset = copy_src.hostQueryReset;
timelineSemaphore = copy_src.timelineSemaphore;
bufferDeviceAddress = copy_src.bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
vulkanMemoryModel = copy_src.vulkanMemoryModel;
vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
shaderOutputViewportIndex = copy_src.shaderOutputViewportIndex;
shaderOutputLayer = copy_src.shaderOutputLayer;
subgroupBroadcastDynamicId = copy_src.subgroupBroadcastDynamicId;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceVulkan12Features& safe_VkPhysicalDeviceVulkan12Features::operator=(const safe_VkPhysicalDeviceVulkan12Features& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
samplerMirrorClampToEdge = copy_src.samplerMirrorClampToEdge;
drawIndirectCount = copy_src.drawIndirectCount;
storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
storagePushConstant8 = copy_src.storagePushConstant8;
shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
shaderFloat16 = copy_src.shaderFloat16;
shaderInt8 = copy_src.shaderInt8;
descriptorIndexing = copy_src.descriptorIndexing;
shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing;
shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing;
shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing;
shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing;
shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing;
shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing;
shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing;
shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing;
shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing;
shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing;
descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind;
descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind;
descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind;
descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind;
descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind;
descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind;
descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending;
descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound;
descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount;
runtimeDescriptorArray = copy_src.runtimeDescriptorArray;
samplerFilterMinmax = copy_src.samplerFilterMinmax;
scalarBlockLayout = copy_src.scalarBlockLayout;
imagelessFramebuffer = copy_src.imagelessFramebuffer;
uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
hostQueryReset = copy_src.hostQueryReset;
timelineSemaphore = copy_src.timelineSemaphore;
bufferDeviceAddress = copy_src.bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
vulkanMemoryModel = copy_src.vulkanMemoryModel;
vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
shaderOutputViewportIndex = copy_src.shaderOutputViewportIndex;
shaderOutputLayer = copy_src.shaderOutputLayer;
subgroupBroadcastDynamicId = copy_src.subgroupBroadcastDynamicId;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceVulkan12Features::~safe_VkPhysicalDeviceVulkan12Features()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVulkan12Features::initialize(const VkPhysicalDeviceVulkan12Features* in_struct)
{
sType = in_struct->sType;
samplerMirrorClampToEdge = in_struct->samplerMirrorClampToEdge;
drawIndirectCount = in_struct->drawIndirectCount;
storageBuffer8BitAccess = in_struct->storageBuffer8BitAccess;
uniformAndStorageBuffer8BitAccess = in_struct->uniformAndStorageBuffer8BitAccess;
storagePushConstant8 = in_struct->storagePushConstant8;
shaderBufferInt64Atomics = in_struct->shaderBufferInt64Atomics;
shaderSharedInt64Atomics = in_struct->shaderSharedInt64Atomics;
shaderFloat16 = in_struct->shaderFloat16;
shaderInt8 = in_struct->shaderInt8;
descriptorIndexing = in_struct->descriptorIndexing;
shaderInputAttachmentArrayDynamicIndexing = in_struct->shaderInputAttachmentArrayDynamicIndexing;
shaderUniformTexelBufferArrayDynamicIndexing = in_struct->shaderUniformTexelBufferArrayDynamicIndexing;
shaderStorageTexelBufferArrayDynamicIndexing = in_struct->shaderStorageTexelBufferArrayDynamicIndexing;
shaderUniformBufferArrayNonUniformIndexing = in_struct->shaderUniformBufferArrayNonUniformIndexing;
shaderSampledImageArrayNonUniformIndexing = in_struct->shaderSampledImageArrayNonUniformIndexing;
shaderStorageBufferArrayNonUniformIndexing = in_struct->shaderStorageBufferArrayNonUniformIndexing;
shaderStorageImageArrayNonUniformIndexing = in_struct->shaderStorageImageArrayNonUniformIndexing;
shaderInputAttachmentArrayNonUniformIndexing = in_struct->shaderInputAttachmentArrayNonUniformIndexing;
shaderUniformTexelBufferArrayNonUniformIndexing = in_struct->shaderUniformTexelBufferArrayNonUniformIndexing;
shaderStorageTexelBufferArrayNonUniformIndexing = in_struct->shaderStorageTexelBufferArrayNonUniformIndexing;
descriptorBindingUniformBufferUpdateAfterBind = in_struct->descriptorBindingUniformBufferUpdateAfterBind;
descriptorBindingSampledImageUpdateAfterBind = in_struct->descriptorBindingSampledImageUpdateAfterBind;
descriptorBindingStorageImageUpdateAfterBind = in_struct->descriptorBindingStorageImageUpdateAfterBind;
descriptorBindingStorageBufferUpdateAfterBind = in_struct->descriptorBindingStorageBufferUpdateAfterBind;
descriptorBindingUniformTexelBufferUpdateAfterBind = in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind;
descriptorBindingStorageTexelBufferUpdateAfterBind = in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind;
descriptorBindingUpdateUnusedWhilePending = in_struct->descriptorBindingUpdateUnusedWhilePending;
descriptorBindingPartiallyBound = in_struct->descriptorBindingPartiallyBound;
descriptorBindingVariableDescriptorCount = in_struct->descriptorBindingVariableDescriptorCount;
runtimeDescriptorArray = in_struct->runtimeDescriptorArray;
samplerFilterMinmax = in_struct->samplerFilterMinmax;
scalarBlockLayout = in_struct->scalarBlockLayout;
imagelessFramebuffer = in_struct->imagelessFramebuffer;
uniformBufferStandardLayout = in_struct->uniformBufferStandardLayout;
shaderSubgroupExtendedTypes = in_struct->shaderSubgroupExtendedTypes;
separateDepthStencilLayouts = in_struct->separateDepthStencilLayouts;
hostQueryReset = in_struct->hostQueryReset;
timelineSemaphore = in_struct->timelineSemaphore;
bufferDeviceAddress = in_struct->bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice;
vulkanMemoryModel = in_struct->vulkanMemoryModel;
vulkanMemoryModelDeviceScope = in_struct->vulkanMemoryModelDeviceScope;
vulkanMemoryModelAvailabilityVisibilityChains = in_struct->vulkanMemoryModelAvailabilityVisibilityChains;
shaderOutputViewportIndex = in_struct->shaderOutputViewportIndex;
shaderOutputLayer = in_struct->shaderOutputLayer;
subgroupBroadcastDynamicId = in_struct->subgroupBroadcastDynamicId;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceVulkan12Features::initialize(const safe_VkPhysicalDeviceVulkan12Features* copy_src)
{
sType = copy_src->sType;
samplerMirrorClampToEdge = copy_src->samplerMirrorClampToEdge;
drawIndirectCount = copy_src->drawIndirectCount;
storageBuffer8BitAccess = copy_src->storageBuffer8BitAccess;
uniformAndStorageBuffer8BitAccess = copy_src->uniformAndStorageBuffer8BitAccess;
storagePushConstant8 = copy_src->storagePushConstant8;
shaderBufferInt64Atomics = copy_src->shaderBufferInt64Atomics;
shaderSharedInt64Atomics = copy_src->shaderSharedInt64Atomics;
shaderFloat16 = copy_src->shaderFloat16;
shaderInt8 = copy_src->shaderInt8;
descriptorIndexing = copy_src->descriptorIndexing;
shaderInputAttachmentArrayDynamicIndexing = copy_src->shaderInputAttachmentArrayDynamicIndexing;
shaderUniformTexelBufferArrayDynamicIndexing = copy_src->shaderUniformTexelBufferArrayDynamicIndexing;
shaderStorageTexelBufferArrayDynamicIndexing = copy_src->shaderStorageTexelBufferArrayDynamicIndexing;
shaderUniformBufferArrayNonUniformIndexing = copy_src->shaderUniformBufferArrayNonUniformIndexing;
shaderSampledImageArrayNonUniformIndexing = copy_src->shaderSampledImageArrayNonUniformIndexing;
shaderStorageBufferArrayNonUniformIndexing = copy_src->shaderStorageBufferArrayNonUniformIndexing;
shaderStorageImageArrayNonUniformIndexing = copy_src->shaderStorageImageArrayNonUniformIndexing;
shaderInputAttachmentArrayNonUniformIndexing = copy_src->shaderInputAttachmentArrayNonUniformIndexing;
shaderUniformTexelBufferArrayNonUniformIndexing = copy_src->shaderUniformTexelBufferArrayNonUniformIndexing;
shaderStorageTexelBufferArrayNonUniformIndexing = copy_src->shaderStorageTexelBufferArrayNonUniformIndexing;
descriptorBindingUniformBufferUpdateAfterBind = copy_src->descriptorBindingUniformBufferUpdateAfterBind;
descriptorBindingSampledImageUpdateAfterBind = copy_src->descriptorBindingSampledImageUpdateAfterBind;
descriptorBindingStorageImageUpdateAfterBind = copy_src->descriptorBindingStorageImageUpdateAfterBind;
descriptorBindingStorageBufferUpdateAfterBind = copy_src->descriptorBindingStorageBufferUpdateAfterBind;
descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src->descriptorBindingUniformTexelBufferUpdateAfterBind;
descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src->descriptorBindingStorageTexelBufferUpdateAfterBind;
descriptorBindingUpdateUnusedWhilePending = copy_src->descriptorBindingUpdateUnusedWhilePending;
descriptorBindingPartiallyBound = copy_src->descriptorBindingPartiallyBound;
descriptorBindingVariableDescriptorCount = copy_src->descriptorBindingVariableDescriptorCount;
runtimeDescriptorArray = copy_src->runtimeDescriptorArray;
samplerFilterMinmax = copy_src->samplerFilterMinmax;
scalarBlockLayout = copy_src->scalarBlockLayout;
imagelessFramebuffer = copy_src->imagelessFramebuffer;
uniformBufferStandardLayout = copy_src->uniformBufferStandardLayout;
shaderSubgroupExtendedTypes = copy_src->shaderSubgroupExtendedTypes;
separateDepthStencilLayouts = copy_src->separateDepthStencilLayouts;
hostQueryReset = copy_src->hostQueryReset;
timelineSemaphore = copy_src->timelineSemaphore;
bufferDeviceAddress = copy_src->bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice;
vulkanMemoryModel = copy_src->vulkanMemoryModel;
vulkanMemoryModelDeviceScope = copy_src->vulkanMemoryModelDeviceScope;
vulkanMemoryModelAvailabilityVisibilityChains = copy_src->vulkanMemoryModelAvailabilityVisibilityChains;
shaderOutputViewportIndex = copy_src->shaderOutputViewportIndex;
shaderOutputLayer = copy_src->shaderOutputLayer;
subgroupBroadcastDynamicId = copy_src->subgroupBroadcastDynamicId;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties* in_struct) :
sType(in_struct->sType),
driverID(in_struct->driverID),
conformanceVersion(in_struct->conformanceVersion),
denormBehaviorIndependence(in_struct->denormBehaviorIndependence),
roundingModeIndependence(in_struct->roundingModeIndependence),
shaderSignedZeroInfNanPreserveFloat16(in_struct->shaderSignedZeroInfNanPreserveFloat16),
shaderSignedZeroInfNanPreserveFloat32(in_struct->shaderSignedZeroInfNanPreserveFloat32),
shaderSignedZeroInfNanPreserveFloat64(in_struct->shaderSignedZeroInfNanPreserveFloat64),
shaderDenormPreserveFloat16(in_struct->shaderDenormPreserveFloat16),
shaderDenormPreserveFloat32(in_struct->shaderDenormPreserveFloat32),
shaderDenormPreserveFloat64(in_struct->shaderDenormPreserveFloat64),
shaderDenormFlushToZeroFloat16(in_struct->shaderDenormFlushToZeroFloat16),
shaderDenormFlushToZeroFloat32(in_struct->shaderDenormFlushToZeroFloat32),
shaderDenormFlushToZeroFloat64(in_struct->shaderDenormFlushToZeroFloat64),
shaderRoundingModeRTEFloat16(in_struct->shaderRoundingModeRTEFloat16),
shaderRoundingModeRTEFloat32(in_struct->shaderRoundingModeRTEFloat32),
shaderRoundingModeRTEFloat64(in_struct->shaderRoundingModeRTEFloat64),
shaderRoundingModeRTZFloat16(in_struct->shaderRoundingModeRTZFloat16),
shaderRoundingModeRTZFloat32(in_struct->shaderRoundingModeRTZFloat32),
shaderRoundingModeRTZFloat64(in_struct->shaderRoundingModeRTZFloat64),
maxUpdateAfterBindDescriptorsInAllPools(in_struct->maxUpdateAfterBindDescriptorsInAllPools),
shaderUniformBufferArrayNonUniformIndexingNative(in_struct->shaderUniformBufferArrayNonUniformIndexingNative),
shaderSampledImageArrayNonUniformIndexingNative(in_struct->shaderSampledImageArrayNonUniformIndexingNative),
shaderStorageBufferArrayNonUniformIndexingNative(in_struct->shaderStorageBufferArrayNonUniformIndexingNative),
shaderStorageImageArrayNonUniformIndexingNative(in_struct->shaderStorageImageArrayNonUniformIndexingNative),
shaderInputAttachmentArrayNonUniformIndexingNative(in_struct->shaderInputAttachmentArrayNonUniformIndexingNative),
robustBufferAccessUpdateAfterBind(in_struct->robustBufferAccessUpdateAfterBind),
quadDivergentImplicitLod(in_struct->quadDivergentImplicitLod),
maxPerStageDescriptorUpdateAfterBindSamplers(in_struct->maxPerStageDescriptorUpdateAfterBindSamplers),
maxPerStageDescriptorUpdateAfterBindUniformBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers),
maxPerStageDescriptorUpdateAfterBindStorageBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers),
maxPerStageDescriptorUpdateAfterBindSampledImages(in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages),
maxPerStageDescriptorUpdateAfterBindStorageImages(in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages),
maxPerStageDescriptorUpdateAfterBindInputAttachments(in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments),
maxPerStageUpdateAfterBindResources(in_struct->maxPerStageUpdateAfterBindResources),
maxDescriptorSetUpdateAfterBindSamplers(in_struct->maxDescriptorSetUpdateAfterBindSamplers),
maxDescriptorSetUpdateAfterBindUniformBuffers(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers),
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),
maxDescriptorSetUpdateAfterBindStorageBuffers(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers),
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),
maxDescriptorSetUpdateAfterBindSampledImages(in_struct->maxDescriptorSetUpdateAfterBindSampledImages),
maxDescriptorSetUpdateAfterBindStorageImages(in_struct->maxDescriptorSetUpdateAfterBindStorageImages),
maxDescriptorSetUpdateAfterBindInputAttachments(in_struct->maxDescriptorSetUpdateAfterBindInputAttachments),
supportedDepthResolveModes(in_struct->supportedDepthResolveModes),
supportedStencilResolveModes(in_struct->supportedStencilResolveModes),
independentResolveNone(in_struct->independentResolveNone),
independentResolve(in_struct->independentResolve),
filterMinmaxSingleComponentFormats(in_struct->filterMinmaxSingleComponentFormats),
filterMinmaxImageComponentMapping(in_struct->filterMinmaxImageComponentMapping),
maxTimelineSemaphoreValueDifference(in_struct->maxTimelineSemaphoreValueDifference),
framebufferIntegerColorSampleCounts(in_struct->framebufferIntegerColorSampleCounts)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = in_struct->driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = in_struct->driverInfo[i];
}
}
safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties(const safe_VkPhysicalDeviceVulkan12Properties& copy_src)
{
sType = copy_src.sType;
driverID = copy_src.driverID;
conformanceVersion = copy_src.conformanceVersion;
denormBehaviorIndependence = copy_src.denormBehaviorIndependence;
roundingModeIndependence = copy_src.roundingModeIndependence;
shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16;
shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32;
shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64;
shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16;
shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32;
shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64;
shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16;
shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32;
shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64;
shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16;
shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32;
shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64;
shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16;
shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32;
shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64;
maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools;
shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative;
shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative;
shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative;
shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative;
shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative;
robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind;
quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod;
maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers;
maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages;
maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages;
maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments;
maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources;
maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers;
maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers;
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers;
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages;
maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages;
maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments;
supportedDepthResolveModes = copy_src.supportedDepthResolveModes;
supportedStencilResolveModes = copy_src.supportedStencilResolveModes;
independentResolveNone = copy_src.independentResolveNone;
independentResolve = copy_src.independentResolve;
filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
framebufferIntegerColorSampleCounts = copy_src.framebufferIntegerColorSampleCounts;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = copy_src.driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = copy_src.driverInfo[i];
}
}
safe_VkPhysicalDeviceVulkan12Properties& safe_VkPhysicalDeviceVulkan12Properties::operator=(const safe_VkPhysicalDeviceVulkan12Properties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
driverID = copy_src.driverID;
conformanceVersion = copy_src.conformanceVersion;
denormBehaviorIndependence = copy_src.denormBehaviorIndependence;
roundingModeIndependence = copy_src.roundingModeIndependence;
shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16;
shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32;
shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64;
shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16;
shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32;
shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64;
shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16;
shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32;
shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64;
shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16;
shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32;
shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64;
shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16;
shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32;
shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64;
maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools;
shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative;
shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative;
shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative;
shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative;
shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative;
robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind;
quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod;
maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers;
maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages;
maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages;
maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments;
maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources;
maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers;
maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers;
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers;
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages;
maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages;
maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments;
supportedDepthResolveModes = copy_src.supportedDepthResolveModes;
supportedStencilResolveModes = copy_src.supportedStencilResolveModes;
independentResolveNone = copy_src.independentResolveNone;
independentResolve = copy_src.independentResolve;
filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
framebufferIntegerColorSampleCounts = copy_src.framebufferIntegerColorSampleCounts;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = copy_src.driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = copy_src.driverInfo[i];
}
return *this;
}
safe_VkPhysicalDeviceVulkan12Properties::~safe_VkPhysicalDeviceVulkan12Properties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVulkan12Properties::initialize(const VkPhysicalDeviceVulkan12Properties* in_struct)
{
sType = in_struct->sType;
driverID = in_struct->driverID;
conformanceVersion = in_struct->conformanceVersion;
denormBehaviorIndependence = in_struct->denormBehaviorIndependence;
roundingModeIndependence = in_struct->roundingModeIndependence;
shaderSignedZeroInfNanPreserveFloat16 = in_struct->shaderSignedZeroInfNanPreserveFloat16;
shaderSignedZeroInfNanPreserveFloat32 = in_struct->shaderSignedZeroInfNanPreserveFloat32;
shaderSignedZeroInfNanPreserveFloat64 = in_struct->shaderSignedZeroInfNanPreserveFloat64;
shaderDenormPreserveFloat16 = in_struct->shaderDenormPreserveFloat16;
shaderDenormPreserveFloat32 = in_struct->shaderDenormPreserveFloat32;
shaderDenormPreserveFloat64 = in_struct->shaderDenormPreserveFloat64;
shaderDenormFlushToZeroFloat16 = in_struct->shaderDenormFlushToZeroFloat16;
shaderDenormFlushToZeroFloat32 = in_struct->shaderDenormFlushToZeroFloat32;
shaderDenormFlushToZeroFloat64 = in_struct->shaderDenormFlushToZeroFloat64;
shaderRoundingModeRTEFloat16 = in_struct->shaderRoundingModeRTEFloat16;
shaderRoundingModeRTEFloat32 = in_struct->shaderRoundingModeRTEFloat32;
shaderRoundingModeRTEFloat64 = in_struct->shaderRoundingModeRTEFloat64;
shaderRoundingModeRTZFloat16 = in_struct->shaderRoundingModeRTZFloat16;
shaderRoundingModeRTZFloat32 = in_struct->shaderRoundingModeRTZFloat32;
shaderRoundingModeRTZFloat64 = in_struct->shaderRoundingModeRTZFloat64;
maxUpdateAfterBindDescriptorsInAllPools = in_struct->maxUpdateAfterBindDescriptorsInAllPools;
shaderUniformBufferArrayNonUniformIndexingNative = in_struct->shaderUniformBufferArrayNonUniformIndexingNative;
shaderSampledImageArrayNonUniformIndexingNative = in_struct->shaderSampledImageArrayNonUniformIndexingNative;
shaderStorageBufferArrayNonUniformIndexingNative = in_struct->shaderStorageBufferArrayNonUniformIndexingNative;
shaderStorageImageArrayNonUniformIndexingNative = in_struct->shaderStorageImageArrayNonUniformIndexingNative;
shaderInputAttachmentArrayNonUniformIndexingNative = in_struct->shaderInputAttachmentArrayNonUniformIndexingNative;
robustBufferAccessUpdateAfterBind = in_struct->robustBufferAccessUpdateAfterBind;
quadDivergentImplicitLod = in_struct->quadDivergentImplicitLod;
maxPerStageDescriptorUpdateAfterBindSamplers = in_struct->maxPerStageDescriptorUpdateAfterBindSamplers;
maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
maxPerStageDescriptorUpdateAfterBindSampledImages = in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages;
maxPerStageDescriptorUpdateAfterBindStorageImages = in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages;
maxPerStageDescriptorUpdateAfterBindInputAttachments = in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments;
maxPerStageUpdateAfterBindResources = in_struct->maxPerStageUpdateAfterBindResources;
maxDescriptorSetUpdateAfterBindSamplers = in_struct->maxDescriptorSetUpdateAfterBindSamplers;
maxDescriptorSetUpdateAfterBindUniformBuffers = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers;
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
maxDescriptorSetUpdateAfterBindStorageBuffers = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers;
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
maxDescriptorSetUpdateAfterBindSampledImages = in_struct->maxDescriptorSetUpdateAfterBindSampledImages;
maxDescriptorSetUpdateAfterBindStorageImages = in_struct->maxDescriptorSetUpdateAfterBindStorageImages;
maxDescriptorSetUpdateAfterBindInputAttachments = in_struct->maxDescriptorSetUpdateAfterBindInputAttachments;
supportedDepthResolveModes = in_struct->supportedDepthResolveModes;
supportedStencilResolveModes = in_struct->supportedStencilResolveModes;
independentResolveNone = in_struct->independentResolveNone;
independentResolve = in_struct->independentResolve;
filterMinmaxSingleComponentFormats = in_struct->filterMinmaxSingleComponentFormats;
filterMinmaxImageComponentMapping = in_struct->filterMinmaxImageComponentMapping;
maxTimelineSemaphoreValueDifference = in_struct->maxTimelineSemaphoreValueDifference;
framebufferIntegerColorSampleCounts = in_struct->framebufferIntegerColorSampleCounts;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = in_struct->driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = in_struct->driverInfo[i];
}
}
void safe_VkPhysicalDeviceVulkan12Properties::initialize(const safe_VkPhysicalDeviceVulkan12Properties* copy_src)
{
sType = copy_src->sType;
driverID = copy_src->driverID;
conformanceVersion = copy_src->conformanceVersion;
denormBehaviorIndependence = copy_src->denormBehaviorIndependence;
roundingModeIndependence = copy_src->roundingModeIndependence;
shaderSignedZeroInfNanPreserveFloat16 = copy_src->shaderSignedZeroInfNanPreserveFloat16;
shaderSignedZeroInfNanPreserveFloat32 = copy_src->shaderSignedZeroInfNanPreserveFloat32;
shaderSignedZeroInfNanPreserveFloat64 = copy_src->shaderSignedZeroInfNanPreserveFloat64;
shaderDenormPreserveFloat16 = copy_src->shaderDenormPreserveFloat16;
shaderDenormPreserveFloat32 = copy_src->shaderDenormPreserveFloat32;
shaderDenormPreserveFloat64 = copy_src->shaderDenormPreserveFloat64;
shaderDenormFlushToZeroFloat16 = copy_src->shaderDenormFlushToZeroFloat16;
shaderDenormFlushToZeroFloat32 = copy_src->shaderDenormFlushToZeroFloat32;
shaderDenormFlushToZeroFloat64 = copy_src->shaderDenormFlushToZeroFloat64;
shaderRoundingModeRTEFloat16 = copy_src->shaderRoundingModeRTEFloat16;
shaderRoundingModeRTEFloat32 = copy_src->shaderRoundingModeRTEFloat32;
shaderRoundingModeRTEFloat64 = copy_src->shaderRoundingModeRTEFloat64;
shaderRoundingModeRTZFloat16 = copy_src->shaderRoundingModeRTZFloat16;
shaderRoundingModeRTZFloat32 = copy_src->shaderRoundingModeRTZFloat32;
shaderRoundingModeRTZFloat64 = copy_src->shaderRoundingModeRTZFloat64;
maxUpdateAfterBindDescriptorsInAllPools = copy_src->maxUpdateAfterBindDescriptorsInAllPools;
shaderUniformBufferArrayNonUniformIndexingNative = copy_src->shaderUniformBufferArrayNonUniformIndexingNative;
shaderSampledImageArrayNonUniformIndexingNative = copy_src->shaderSampledImageArrayNonUniformIndexingNative;
shaderStorageBufferArrayNonUniformIndexingNative = copy_src->shaderStorageBufferArrayNonUniformIndexingNative;
shaderStorageImageArrayNonUniformIndexingNative = copy_src->shaderStorageImageArrayNonUniformIndexingNative;
shaderInputAttachmentArrayNonUniformIndexingNative = copy_src->shaderInputAttachmentArrayNonUniformIndexingNative;
robustBufferAccessUpdateAfterBind = copy_src->robustBufferAccessUpdateAfterBind;
quadDivergentImplicitLod = copy_src->quadDivergentImplicitLod;
maxPerStageDescriptorUpdateAfterBindSamplers = copy_src->maxPerStageDescriptorUpdateAfterBindSamplers;
maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src->maxPerStageDescriptorUpdateAfterBindSampledImages;
maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src->maxPerStageDescriptorUpdateAfterBindStorageImages;
maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src->maxPerStageDescriptorUpdateAfterBindInputAttachments;
maxPerStageUpdateAfterBindResources = copy_src->maxPerStageUpdateAfterBindResources;
maxDescriptorSetUpdateAfterBindSamplers = copy_src->maxDescriptorSetUpdateAfterBindSamplers;
maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffers;
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffers;
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
maxDescriptorSetUpdateAfterBindSampledImages = copy_src->maxDescriptorSetUpdateAfterBindSampledImages;
maxDescriptorSetUpdateAfterBindStorageImages = copy_src->maxDescriptorSetUpdateAfterBindStorageImages;
maxDescriptorSetUpdateAfterBindInputAttachments = copy_src->maxDescriptorSetUpdateAfterBindInputAttachments;
supportedDepthResolveModes = copy_src->supportedDepthResolveModes;
supportedStencilResolveModes = copy_src->supportedStencilResolveModes;
independentResolveNone = copy_src->independentResolveNone;
independentResolve = copy_src->independentResolve;
filterMinmaxSingleComponentFormats = copy_src->filterMinmaxSingleComponentFormats;
filterMinmaxImageComponentMapping = copy_src->filterMinmaxImageComponentMapping;
maxTimelineSemaphoreValueDifference = copy_src->maxTimelineSemaphoreValueDifference;
framebufferIntegerColorSampleCounts = copy_src->framebufferIntegerColorSampleCounts;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = copy_src->driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = copy_src->driverInfo[i];
}
}
safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* in_struct) :
sType(in_struct->sType),
viewFormatCount(in_struct->viewFormatCount),
pViewFormats(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewFormats) {
pViewFormats = new VkFormat[in_struct->viewFormatCount];
memcpy ((void *)pViewFormats, (void *)in_struct->pViewFormats, sizeof(VkFormat)*in_struct->viewFormatCount);
}
}
safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo() :
sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO),
pNext(nullptr),
pViewFormats(nullptr)
{}
safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo(const safe_VkImageFormatListCreateInfo& copy_src)
{
sType = copy_src.sType;
viewFormatCount = copy_src.viewFormatCount;
pViewFormats = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewFormats) {
pViewFormats = new VkFormat[copy_src.viewFormatCount];
memcpy ((void *)pViewFormats, (void *)copy_src.pViewFormats, sizeof(VkFormat)*copy_src.viewFormatCount);
}
}
safe_VkImageFormatListCreateInfo& safe_VkImageFormatListCreateInfo::operator=(const safe_VkImageFormatListCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pViewFormats)
delete[] pViewFormats;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
viewFormatCount = copy_src.viewFormatCount;
pViewFormats = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewFormats) {
pViewFormats = new VkFormat[copy_src.viewFormatCount];
memcpy ((void *)pViewFormats, (void *)copy_src.pViewFormats, sizeof(VkFormat)*copy_src.viewFormatCount);
}
return *this;
}
safe_VkImageFormatListCreateInfo::~safe_VkImageFormatListCreateInfo()
{
if (pViewFormats)
delete[] pViewFormats;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageFormatListCreateInfo::initialize(const VkImageFormatListCreateInfo* in_struct)
{
sType = in_struct->sType;
viewFormatCount = in_struct->viewFormatCount;
pViewFormats = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewFormats) {
pViewFormats = new VkFormat[in_struct->viewFormatCount];
memcpy ((void *)pViewFormats, (void *)in_struct->pViewFormats, sizeof(VkFormat)*in_struct->viewFormatCount);
}
}
void safe_VkImageFormatListCreateInfo::initialize(const safe_VkImageFormatListCreateInfo* copy_src)
{
sType = copy_src->sType;
viewFormatCount = copy_src->viewFormatCount;
pViewFormats = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pViewFormats) {
pViewFormats = new VkFormat[copy_src->viewFormatCount];
memcpy ((void *)pViewFormats, (void *)copy_src->pViewFormats, sizeof(VkFormat)*copy_src->viewFormatCount);
}
}
safe_VkAttachmentDescription2::safe_VkAttachmentDescription2(const VkAttachmentDescription2* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
format(in_struct->format),
samples(in_struct->samples),
loadOp(in_struct->loadOp),
storeOp(in_struct->storeOp),
stencilLoadOp(in_struct->stencilLoadOp),
stencilStoreOp(in_struct->stencilStoreOp),
initialLayout(in_struct->initialLayout),
finalLayout(in_struct->finalLayout)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAttachmentDescription2::safe_VkAttachmentDescription2() :
sType(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2),
pNext(nullptr)
{}
safe_VkAttachmentDescription2::safe_VkAttachmentDescription2(const safe_VkAttachmentDescription2& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
format = copy_src.format;
samples = copy_src.samples;
loadOp = copy_src.loadOp;
storeOp = copy_src.storeOp;
stencilLoadOp = copy_src.stencilLoadOp;
stencilStoreOp = copy_src.stencilStoreOp;
initialLayout = copy_src.initialLayout;
finalLayout = copy_src.finalLayout;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAttachmentDescription2& safe_VkAttachmentDescription2::operator=(const safe_VkAttachmentDescription2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
format = copy_src.format;
samples = copy_src.samples;
loadOp = copy_src.loadOp;
storeOp = copy_src.storeOp;
stencilLoadOp = copy_src.stencilLoadOp;
stencilStoreOp = copy_src.stencilStoreOp;
initialLayout = copy_src.initialLayout;
finalLayout = copy_src.finalLayout;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAttachmentDescription2::~safe_VkAttachmentDescription2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAttachmentDescription2::initialize(const VkAttachmentDescription2* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
format = in_struct->format;
samples = in_struct->samples;
loadOp = in_struct->loadOp;
storeOp = in_struct->storeOp;
stencilLoadOp = in_struct->stencilLoadOp;
stencilStoreOp = in_struct->stencilStoreOp;
initialLayout = in_struct->initialLayout;
finalLayout = in_struct->finalLayout;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAttachmentDescription2::initialize(const safe_VkAttachmentDescription2* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
format = copy_src->format;
samples = copy_src->samples;
loadOp = copy_src->loadOp;
storeOp = copy_src->storeOp;
stencilLoadOp = copy_src->stencilLoadOp;
stencilStoreOp = copy_src->stencilStoreOp;
initialLayout = copy_src->initialLayout;
finalLayout = copy_src->finalLayout;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAttachmentReference2::safe_VkAttachmentReference2(const VkAttachmentReference2* in_struct) :
sType(in_struct->sType),
attachment(in_struct->attachment),
layout(in_struct->layout),
aspectMask(in_struct->aspectMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAttachmentReference2::safe_VkAttachmentReference2() :
sType(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2),
pNext(nullptr)
{}
safe_VkAttachmentReference2::safe_VkAttachmentReference2(const safe_VkAttachmentReference2& copy_src)
{
sType = copy_src.sType;
attachment = copy_src.attachment;
layout = copy_src.layout;
aspectMask = copy_src.aspectMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAttachmentReference2& safe_VkAttachmentReference2::operator=(const safe_VkAttachmentReference2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
attachment = copy_src.attachment;
layout = copy_src.layout;
aspectMask = copy_src.aspectMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAttachmentReference2::~safe_VkAttachmentReference2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAttachmentReference2::initialize(const VkAttachmentReference2* in_struct)
{
sType = in_struct->sType;
attachment = in_struct->attachment;
layout = in_struct->layout;
aspectMask = in_struct->aspectMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAttachmentReference2::initialize(const safe_VkAttachmentReference2* copy_src)
{
sType = copy_src->sType;
attachment = copy_src->attachment;
layout = copy_src->layout;
aspectMask = copy_src->aspectMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSubpassDescription2::safe_VkSubpassDescription2(const VkSubpassDescription2* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
pipelineBindPoint(in_struct->pipelineBindPoint),
viewMask(in_struct->viewMask),
inputAttachmentCount(in_struct->inputAttachmentCount),
pInputAttachments(nullptr),
colorAttachmentCount(in_struct->colorAttachmentCount),
pColorAttachments(nullptr),
pResolveAttachments(nullptr),
pDepthStencilAttachment(nullptr),
preserveAttachmentCount(in_struct->preserveAttachmentCount),
pPreserveAttachments(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (inputAttachmentCount && in_struct->pInputAttachments) {
pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]);
}
}
if (colorAttachmentCount && in_struct->pColorAttachments) {
pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
}
}
if (colorAttachmentCount && in_struct->pResolveAttachments) {
pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]);
}
}
if (in_struct->pDepthStencilAttachment)
pDepthStencilAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilAttachment);
if (in_struct->pPreserveAttachments) {
pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)in_struct->pPreserveAttachments, sizeof(uint32_t)*in_struct->preserveAttachmentCount);
}
}
safe_VkSubpassDescription2::safe_VkSubpassDescription2() :
sType(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2),
pNext(nullptr),
pInputAttachments(nullptr),
pColorAttachments(nullptr),
pResolveAttachments(nullptr),
pDepthStencilAttachment(nullptr),
pPreserveAttachments(nullptr)
{}
safe_VkSubpassDescription2::safe_VkSubpassDescription2(const safe_VkSubpassDescription2& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pipelineBindPoint = copy_src.pipelineBindPoint;
viewMask = copy_src.viewMask;
inputAttachmentCount = copy_src.inputAttachmentCount;
pInputAttachments = nullptr;
colorAttachmentCount = copy_src.colorAttachmentCount;
pColorAttachments = nullptr;
pResolveAttachments = nullptr;
pDepthStencilAttachment = nullptr;
preserveAttachmentCount = copy_src.preserveAttachmentCount;
pPreserveAttachments = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (inputAttachmentCount && copy_src.pInputAttachments) {
pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
pInputAttachments[i].initialize(&copy_src.pInputAttachments[i]);
}
}
if (colorAttachmentCount && copy_src.pColorAttachments) {
pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
}
}
if (colorAttachmentCount && copy_src.pResolveAttachments) {
pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pResolveAttachments[i].initialize(&copy_src.pResolveAttachments[i]);
}
}
if (copy_src.pDepthStencilAttachment)
pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilAttachment);
if (copy_src.pPreserveAttachments) {
pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)copy_src.pPreserveAttachments, sizeof(uint32_t)*copy_src.preserveAttachmentCount);
}
}
safe_VkSubpassDescription2& safe_VkSubpassDescription2::operator=(const safe_VkSubpassDescription2& copy_src)
{
if (&copy_src == this) return *this;
if (pInputAttachments)
delete[] pInputAttachments;
if (pColorAttachments)
delete[] pColorAttachments;
if (pResolveAttachments)
delete[] pResolveAttachments;
if (pDepthStencilAttachment)
delete pDepthStencilAttachment;
if (pPreserveAttachments)
delete[] pPreserveAttachments;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pipelineBindPoint = copy_src.pipelineBindPoint;
viewMask = copy_src.viewMask;
inputAttachmentCount = copy_src.inputAttachmentCount;
pInputAttachments = nullptr;
colorAttachmentCount = copy_src.colorAttachmentCount;
pColorAttachments = nullptr;
pResolveAttachments = nullptr;
pDepthStencilAttachment = nullptr;
preserveAttachmentCount = copy_src.preserveAttachmentCount;
pPreserveAttachments = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (inputAttachmentCount && copy_src.pInputAttachments) {
pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
pInputAttachments[i].initialize(&copy_src.pInputAttachments[i]);
}
}
if (colorAttachmentCount && copy_src.pColorAttachments) {
pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
}
}
if (colorAttachmentCount && copy_src.pResolveAttachments) {
pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pResolveAttachments[i].initialize(&copy_src.pResolveAttachments[i]);
}
}
if (copy_src.pDepthStencilAttachment)
pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilAttachment);
if (copy_src.pPreserveAttachments) {
pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)copy_src.pPreserveAttachments, sizeof(uint32_t)*copy_src.preserveAttachmentCount);
}
return *this;
}
safe_VkSubpassDescription2::~safe_VkSubpassDescription2()
{
if (pInputAttachments)
delete[] pInputAttachments;
if (pColorAttachments)
delete[] pColorAttachments;
if (pResolveAttachments)
delete[] pResolveAttachments;
if (pDepthStencilAttachment)
delete pDepthStencilAttachment;
if (pPreserveAttachments)
delete[] pPreserveAttachments;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSubpassDescription2::initialize(const VkSubpassDescription2* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pipelineBindPoint = in_struct->pipelineBindPoint;
viewMask = in_struct->viewMask;
inputAttachmentCount = in_struct->inputAttachmentCount;
pInputAttachments = nullptr;
colorAttachmentCount = in_struct->colorAttachmentCount;
pColorAttachments = nullptr;
pResolveAttachments = nullptr;
pDepthStencilAttachment = nullptr;
preserveAttachmentCount = in_struct->preserveAttachmentCount;
pPreserveAttachments = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (inputAttachmentCount && in_struct->pInputAttachments) {
pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]);
}
}
if (colorAttachmentCount && in_struct->pColorAttachments) {
pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
}
}
if (colorAttachmentCount && in_struct->pResolveAttachments) {
pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]);
}
}
if (in_struct->pDepthStencilAttachment)
pDepthStencilAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilAttachment);
if (in_struct->pPreserveAttachments) {
pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)in_struct->pPreserveAttachments, sizeof(uint32_t)*in_struct->preserveAttachmentCount);
}
}
void safe_VkSubpassDescription2::initialize(const safe_VkSubpassDescription2* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pipelineBindPoint = copy_src->pipelineBindPoint;
viewMask = copy_src->viewMask;
inputAttachmentCount = copy_src->inputAttachmentCount;
pInputAttachments = nullptr;
colorAttachmentCount = copy_src->colorAttachmentCount;
pColorAttachments = nullptr;
pResolveAttachments = nullptr;
pDepthStencilAttachment = nullptr;
preserveAttachmentCount = copy_src->preserveAttachmentCount;
pPreserveAttachments = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (inputAttachmentCount && copy_src->pInputAttachments) {
pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
pInputAttachments[i].initialize(&copy_src->pInputAttachments[i]);
}
}
if (colorAttachmentCount && copy_src->pColorAttachments) {
pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pColorAttachments[i].initialize(&copy_src->pColorAttachments[i]);
}
}
if (colorAttachmentCount && copy_src->pResolveAttachments) {
pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
pResolveAttachments[i].initialize(&copy_src->pResolveAttachments[i]);
}
}
if (copy_src->pDepthStencilAttachment)
pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src->pDepthStencilAttachment);
if (copy_src->pPreserveAttachments) {
pPreserveAttachments = new uint32_t[copy_src->preserveAttachmentCount];
memcpy ((void *)pPreserveAttachments, (void *)copy_src->pPreserveAttachments, sizeof(uint32_t)*copy_src->preserveAttachmentCount);
}
}
safe_VkSubpassDependency2::safe_VkSubpassDependency2(const VkSubpassDependency2* in_struct) :
sType(in_struct->sType),
srcSubpass(in_struct->srcSubpass),
dstSubpass(in_struct->dstSubpass),
srcStageMask(in_struct->srcStageMask),
dstStageMask(in_struct->dstStageMask),
srcAccessMask(in_struct->srcAccessMask),
dstAccessMask(in_struct->dstAccessMask),
dependencyFlags(in_struct->dependencyFlags),
viewOffset(in_struct->viewOffset)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSubpassDependency2::safe_VkSubpassDependency2() :
sType(VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2),
pNext(nullptr)
{}
safe_VkSubpassDependency2::safe_VkSubpassDependency2(const safe_VkSubpassDependency2& copy_src)
{
sType = copy_src.sType;
srcSubpass = copy_src.srcSubpass;
dstSubpass = copy_src.dstSubpass;
srcStageMask = copy_src.srcStageMask;
dstStageMask = copy_src.dstStageMask;
srcAccessMask = copy_src.srcAccessMask;
dstAccessMask = copy_src.dstAccessMask;
dependencyFlags = copy_src.dependencyFlags;
viewOffset = copy_src.viewOffset;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSubpassDependency2& safe_VkSubpassDependency2::operator=(const safe_VkSubpassDependency2& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcSubpass = copy_src.srcSubpass;
dstSubpass = copy_src.dstSubpass;
srcStageMask = copy_src.srcStageMask;
dstStageMask = copy_src.dstStageMask;
srcAccessMask = copy_src.srcAccessMask;
dstAccessMask = copy_src.dstAccessMask;
dependencyFlags = copy_src.dependencyFlags;
viewOffset = copy_src.viewOffset;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSubpassDependency2::~safe_VkSubpassDependency2()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSubpassDependency2::initialize(const VkSubpassDependency2* in_struct)
{
sType = in_struct->sType;
srcSubpass = in_struct->srcSubpass;
dstSubpass = in_struct->dstSubpass;
srcStageMask = in_struct->srcStageMask;
dstStageMask = in_struct->dstStageMask;
srcAccessMask = in_struct->srcAccessMask;
dstAccessMask = in_struct->dstAccessMask;
dependencyFlags = in_struct->dependencyFlags;
viewOffset = in_struct->viewOffset;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSubpassDependency2::initialize(const safe_VkSubpassDependency2* copy_src)
{
sType = copy_src->sType;
srcSubpass = copy_src->srcSubpass;
dstSubpass = copy_src->dstSubpass;
srcStageMask = copy_src->srcStageMask;
dstStageMask = copy_src->dstStageMask;
srcAccessMask = copy_src->srcAccessMask;
dstAccessMask = copy_src->dstAccessMask;
dependencyFlags = copy_src->dependencyFlags;
viewOffset = copy_src->viewOffset;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
attachmentCount(in_struct->attachmentCount),
pAttachments(nullptr),
subpassCount(in_struct->subpassCount),
pSubpasses(nullptr),
dependencyCount(in_struct->dependencyCount),
pDependencies(nullptr),
correlatedViewMaskCount(in_struct->correlatedViewMaskCount),
pCorrelatedViewMasks(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (attachmentCount && in_struct->pAttachments) {
pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i].initialize(&in_struct->pAttachments[i]);
}
}
if (subpassCount && in_struct->pSubpasses) {
pSubpasses = new safe_VkSubpassDescription2[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
}
}
if (dependencyCount && in_struct->pDependencies) {
pDependencies = new safe_VkSubpassDependency2[dependencyCount];
for (uint32_t i = 0; i < dependencyCount; ++i) {
pDependencies[i].initialize(&in_struct->pDependencies[i]);
}
}
if (in_struct->pCorrelatedViewMasks) {
pCorrelatedViewMasks = new uint32_t[in_struct->correlatedViewMaskCount];
memcpy ((void *)pCorrelatedViewMasks, (void *)in_struct->pCorrelatedViewMasks, sizeof(uint32_t)*in_struct->correlatedViewMaskCount);
}
}
safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2),
pNext(nullptr),
pAttachments(nullptr),
pSubpasses(nullptr),
pDependencies(nullptr),
pCorrelatedViewMasks(nullptr)
{}
safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
subpassCount = copy_src.subpassCount;
pSubpasses = nullptr;
dependencyCount = copy_src.dependencyCount;
pDependencies = nullptr;
correlatedViewMaskCount = copy_src.correlatedViewMaskCount;
pCorrelatedViewMasks = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (attachmentCount && copy_src.pAttachments) {
pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i].initialize(&copy_src.pAttachments[i]);
}
}
if (subpassCount && copy_src.pSubpasses) {
pSubpasses = new safe_VkSubpassDescription2[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
}
}
if (dependencyCount && copy_src.pDependencies) {
pDependencies = new safe_VkSubpassDependency2[dependencyCount];
for (uint32_t i = 0; i < dependencyCount; ++i) {
pDependencies[i].initialize(&copy_src.pDependencies[i]);
}
}
if (copy_src.pCorrelatedViewMasks) {
pCorrelatedViewMasks = new uint32_t[copy_src.correlatedViewMaskCount];
memcpy ((void *)pCorrelatedViewMasks, (void *)copy_src.pCorrelatedViewMasks, sizeof(uint32_t)*copy_src.correlatedViewMaskCount);
}
}
safe_VkRenderPassCreateInfo2& safe_VkRenderPassCreateInfo2::operator=(const safe_VkRenderPassCreateInfo2& copy_src)
{
if (&copy_src == this) return *this;
if (pAttachments)
delete[] pAttachments;
if (pSubpasses)
delete[] pSubpasses;
if (pDependencies)
delete[] pDependencies;
if (pCorrelatedViewMasks)
delete[] pCorrelatedViewMasks;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
subpassCount = copy_src.subpassCount;
pSubpasses = nullptr;
dependencyCount = copy_src.dependencyCount;
pDependencies = nullptr;
correlatedViewMaskCount = copy_src.correlatedViewMaskCount;
pCorrelatedViewMasks = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (attachmentCount && copy_src.pAttachments) {
pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i].initialize(&copy_src.pAttachments[i]);
}
}
if (subpassCount && copy_src.pSubpasses) {
pSubpasses = new safe_VkSubpassDescription2[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
}
}
if (dependencyCount && copy_src.pDependencies) {
pDependencies = new safe_VkSubpassDependency2[dependencyCount];
for (uint32_t i = 0; i < dependencyCount; ++i) {
pDependencies[i].initialize(&copy_src.pDependencies[i]);
}
}
if (copy_src.pCorrelatedViewMasks) {
pCorrelatedViewMasks = new uint32_t[copy_src.correlatedViewMaskCount];
memcpy ((void *)pCorrelatedViewMasks, (void *)copy_src.pCorrelatedViewMasks, sizeof(uint32_t)*copy_src.correlatedViewMaskCount);
}
return *this;
}
safe_VkRenderPassCreateInfo2::~safe_VkRenderPassCreateInfo2()
{
if (pAttachments)
delete[] pAttachments;
if (pSubpasses)
delete[] pSubpasses;
if (pDependencies)
delete[] pDependencies;
if (pCorrelatedViewMasks)
delete[] pCorrelatedViewMasks;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassCreateInfo2::initialize(const VkRenderPassCreateInfo2* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
attachmentCount = in_struct->attachmentCount;
pAttachments = nullptr;
subpassCount = in_struct->subpassCount;
pSubpasses = nullptr;
dependencyCount = in_struct->dependencyCount;
pDependencies = nullptr;
correlatedViewMaskCount = in_struct->correlatedViewMaskCount;
pCorrelatedViewMasks = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (attachmentCount && in_struct->pAttachments) {
pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i].initialize(&in_struct->pAttachments[i]);
}
}
if (subpassCount && in_struct->pSubpasses) {
pSubpasses = new safe_VkSubpassDescription2[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
}
}
if (dependencyCount && in_struct->pDependencies) {
pDependencies = new safe_VkSubpassDependency2[dependencyCount];
for (uint32_t i = 0; i < dependencyCount; ++i) {
pDependencies[i].initialize(&in_struct->pDependencies[i]);
}
}
if (in_struct->pCorrelatedViewMasks) {
pCorrelatedViewMasks = new uint32_t[in_struct->correlatedViewMaskCount];
memcpy ((void *)pCorrelatedViewMasks, (void *)in_struct->pCorrelatedViewMasks, sizeof(uint32_t)*in_struct->correlatedViewMaskCount);
}
}
void safe_VkRenderPassCreateInfo2::initialize(const safe_VkRenderPassCreateInfo2* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
attachmentCount = copy_src->attachmentCount;
pAttachments = nullptr;
subpassCount = copy_src->subpassCount;
pSubpasses = nullptr;
dependencyCount = copy_src->dependencyCount;
pDependencies = nullptr;
correlatedViewMaskCount = copy_src->correlatedViewMaskCount;
pCorrelatedViewMasks = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (attachmentCount && copy_src->pAttachments) {
pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i].initialize(&copy_src->pAttachments[i]);
}
}
if (subpassCount && copy_src->pSubpasses) {
pSubpasses = new safe_VkSubpassDescription2[subpassCount];
for (uint32_t i = 0; i < subpassCount; ++i) {
pSubpasses[i].initialize(&copy_src->pSubpasses[i]);
}
}
if (dependencyCount && copy_src->pDependencies) {
pDependencies = new safe_VkSubpassDependency2[dependencyCount];
for (uint32_t i = 0; i < dependencyCount; ++i) {
pDependencies[i].initialize(&copy_src->pDependencies[i]);
}
}
if (copy_src->pCorrelatedViewMasks) {
pCorrelatedViewMasks = new uint32_t[copy_src->correlatedViewMaskCount];
memcpy ((void *)pCorrelatedViewMasks, (void *)copy_src->pCorrelatedViewMasks, sizeof(uint32_t)*copy_src->correlatedViewMaskCount);
}
}
safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct) :
sType(in_struct->sType),
contents(in_struct->contents)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo() :
sType(VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO),
pNext(nullptr)
{}
safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src)
{
sType = copy_src.sType;
contents = copy_src.contents;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSubpassBeginInfo& safe_VkSubpassBeginInfo::operator=(const safe_VkSubpassBeginInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
contents = copy_src.contents;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSubpassBeginInfo::~safe_VkSubpassBeginInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSubpassBeginInfo::initialize(const VkSubpassBeginInfo* in_struct)
{
sType = in_struct->sType;
contents = in_struct->contents;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSubpassBeginInfo::initialize(const safe_VkSubpassBeginInfo* copy_src)
{
sType = copy_src->sType;
contents = copy_src->contents;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct) :
sType(in_struct->sType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSubpassEndInfo::safe_VkSubpassEndInfo() :
sType(VK_STRUCTURE_TYPE_SUBPASS_END_INFO),
pNext(nullptr)
{}
safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src)
{
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSubpassEndInfo& safe_VkSubpassEndInfo::operator=(const safe_VkSubpassEndInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSubpassEndInfo::~safe_VkSubpassEndInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSubpassEndInfo::initialize(const VkSubpassEndInfo* in_struct)
{
sType = in_struct->sType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSubpassEndInfo::initialize(const safe_VkSubpassEndInfo* copy_src)
{
sType = copy_src->sType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures* in_struct) :
sType(in_struct->sType),
storageBuffer8BitAccess(in_struct->storageBuffer8BitAccess),
uniformAndStorageBuffer8BitAccess(in_struct->uniformAndStorageBuffer8BitAccess),
storagePushConstant8(in_struct->storagePushConstant8)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src)
{
sType = copy_src.sType;
storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
storagePushConstant8 = copy_src.storagePushConstant8;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevice8BitStorageFeatures& safe_VkPhysicalDevice8BitStorageFeatures::operator=(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
storagePushConstant8 = copy_src.storagePushConstant8;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevice8BitStorageFeatures::~safe_VkPhysicalDevice8BitStorageFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevice8BitStorageFeatures::initialize(const VkPhysicalDevice8BitStorageFeatures* in_struct)
{
sType = in_struct->sType;
storageBuffer8BitAccess = in_struct->storageBuffer8BitAccess;
uniformAndStorageBuffer8BitAccess = in_struct->uniformAndStorageBuffer8BitAccess;
storagePushConstant8 = in_struct->storagePushConstant8;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevice8BitStorageFeatures::initialize(const safe_VkPhysicalDevice8BitStorageFeatures* copy_src)
{
sType = copy_src->sType;
storageBuffer8BitAccess = copy_src->storageBuffer8BitAccess;
uniformAndStorageBuffer8BitAccess = copy_src->uniformAndStorageBuffer8BitAccess;
storagePushConstant8 = copy_src->storagePushConstant8;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct) :
sType(in_struct->sType),
driverID(in_struct->driverID),
conformanceVersion(in_struct->conformanceVersion)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = in_struct->driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = in_struct->driverInfo[i];
}
}
safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(const safe_VkPhysicalDeviceDriverProperties& copy_src)
{
sType = copy_src.sType;
driverID = copy_src.driverID;
conformanceVersion = copy_src.conformanceVersion;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = copy_src.driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = copy_src.driverInfo[i];
}
}
safe_VkPhysicalDeviceDriverProperties& safe_VkPhysicalDeviceDriverProperties::operator=(const safe_VkPhysicalDeviceDriverProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
driverID = copy_src.driverID;
conformanceVersion = copy_src.conformanceVersion;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = copy_src.driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = copy_src.driverInfo[i];
}
return *this;
}
safe_VkPhysicalDeviceDriverProperties::~safe_VkPhysicalDeviceDriverProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDriverProperties::initialize(const VkPhysicalDeviceDriverProperties* in_struct)
{
sType = in_struct->sType;
driverID = in_struct->driverID;
conformanceVersion = in_struct->conformanceVersion;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = in_struct->driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = in_struct->driverInfo[i];
}
}
void safe_VkPhysicalDeviceDriverProperties::initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src)
{
sType = copy_src->sType;
driverID = copy_src->driverID;
conformanceVersion = copy_src->conformanceVersion;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
driverName[i] = copy_src->driverName[i];
}
for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
driverInfo[i] = copy_src->driverInfo[i];
}
}
safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct) :
sType(in_struct->sType),
shaderBufferInt64Atomics(in_struct->shaderBufferInt64Atomics),
shaderSharedInt64Atomics(in_struct->shaderSharedInt64Atomics)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src)
{
sType = copy_src.sType;
shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderAtomicInt64Features& safe_VkPhysicalDeviceShaderAtomicInt64Features::operator=(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderAtomicInt64Features::~safe_VkPhysicalDeviceShaderAtomicInt64Features()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderAtomicInt64Features::initialize(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct)
{
sType = in_struct->sType;
shaderBufferInt64Atomics = in_struct->shaderBufferInt64Atomics;
shaderSharedInt64Atomics = in_struct->shaderSharedInt64Atomics;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderAtomicInt64Features::initialize(const safe_VkPhysicalDeviceShaderAtomicInt64Features* copy_src)
{
sType = copy_src->sType;
shaderBufferInt64Atomics = copy_src->shaderBufferInt64Atomics;
shaderSharedInt64Atomics = copy_src->shaderSharedInt64Atomics;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct) :
sType(in_struct->sType),
shaderFloat16(in_struct->shaderFloat16),
shaderInt8(in_struct->shaderInt8)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src)
{
sType = copy_src.sType;
shaderFloat16 = copy_src.shaderFloat16;
shaderInt8 = copy_src.shaderInt8;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderFloat16Int8Features& safe_VkPhysicalDeviceShaderFloat16Int8Features::operator=(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderFloat16 = copy_src.shaderFloat16;
shaderInt8 = copy_src.shaderInt8;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderFloat16Int8Features::~safe_VkPhysicalDeviceShaderFloat16Int8Features()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderFloat16Int8Features::initialize(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct)
{
sType = in_struct->sType;
shaderFloat16 = in_struct->shaderFloat16;
shaderInt8 = in_struct->shaderInt8;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderFloat16Int8Features::initialize(const safe_VkPhysicalDeviceShaderFloat16Int8Features* copy_src)
{
sType = copy_src->sType;
shaderFloat16 = copy_src->shaderFloat16;
shaderInt8 = copy_src->shaderInt8;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties* in_struct) :
sType(in_struct->sType),
denormBehaviorIndependence(in_struct->denormBehaviorIndependence),
roundingModeIndependence(in_struct->roundingModeIndependence),
shaderSignedZeroInfNanPreserveFloat16(in_struct->shaderSignedZeroInfNanPreserveFloat16),
shaderSignedZeroInfNanPreserveFloat32(in_struct->shaderSignedZeroInfNanPreserveFloat32),
shaderSignedZeroInfNanPreserveFloat64(in_struct->shaderSignedZeroInfNanPreserveFloat64),
shaderDenormPreserveFloat16(in_struct->shaderDenormPreserveFloat16),
shaderDenormPreserveFloat32(in_struct->shaderDenormPreserveFloat32),
shaderDenormPreserveFloat64(in_struct->shaderDenormPreserveFloat64),
shaderDenormFlushToZeroFloat16(in_struct->shaderDenormFlushToZeroFloat16),
shaderDenormFlushToZeroFloat32(in_struct->shaderDenormFlushToZeroFloat32),
shaderDenormFlushToZeroFloat64(in_struct->shaderDenormFlushToZeroFloat64),
shaderRoundingModeRTEFloat16(in_struct->shaderRoundingModeRTEFloat16),
shaderRoundingModeRTEFloat32(in_struct->shaderRoundingModeRTEFloat32),
shaderRoundingModeRTEFloat64(in_struct->shaderRoundingModeRTEFloat64),
shaderRoundingModeRTZFloat16(in_struct->shaderRoundingModeRTZFloat16),
shaderRoundingModeRTZFloat32(in_struct->shaderRoundingModeRTZFloat32),
shaderRoundingModeRTZFloat64(in_struct->shaderRoundingModeRTZFloat64)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src)
{
sType = copy_src.sType;
denormBehaviorIndependence = copy_src.denormBehaviorIndependence;
roundingModeIndependence = copy_src.roundingModeIndependence;
shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16;
shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32;
shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64;
shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16;
shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32;
shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64;
shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16;
shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32;
shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64;
shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16;
shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32;
shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64;
shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16;
shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32;
shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFloatControlsProperties& safe_VkPhysicalDeviceFloatControlsProperties::operator=(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
denormBehaviorIndependence = copy_src.denormBehaviorIndependence;
roundingModeIndependence = copy_src.roundingModeIndependence;
shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16;
shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32;
shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64;
shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16;
shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32;
shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64;
shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16;
shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32;
shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64;
shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16;
shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32;
shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64;
shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16;
shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32;
shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFloatControlsProperties::~safe_VkPhysicalDeviceFloatControlsProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFloatControlsProperties::initialize(const VkPhysicalDeviceFloatControlsProperties* in_struct)
{
sType = in_struct->sType;
denormBehaviorIndependence = in_struct->denormBehaviorIndependence;
roundingModeIndependence = in_struct->roundingModeIndependence;
shaderSignedZeroInfNanPreserveFloat16 = in_struct->shaderSignedZeroInfNanPreserveFloat16;
shaderSignedZeroInfNanPreserveFloat32 = in_struct->shaderSignedZeroInfNanPreserveFloat32;
shaderSignedZeroInfNanPreserveFloat64 = in_struct->shaderSignedZeroInfNanPreserveFloat64;
shaderDenormPreserveFloat16 = in_struct->shaderDenormPreserveFloat16;
shaderDenormPreserveFloat32 = in_struct->shaderDenormPreserveFloat32;
shaderDenormPreserveFloat64 = in_struct->shaderDenormPreserveFloat64;
shaderDenormFlushToZeroFloat16 = in_struct->shaderDenormFlushToZeroFloat16;
shaderDenormFlushToZeroFloat32 = in_struct->shaderDenormFlushToZeroFloat32;
shaderDenormFlushToZeroFloat64 = in_struct->shaderDenormFlushToZeroFloat64;
shaderRoundingModeRTEFloat16 = in_struct->shaderRoundingModeRTEFloat16;
shaderRoundingModeRTEFloat32 = in_struct->shaderRoundingModeRTEFloat32;
shaderRoundingModeRTEFloat64 = in_struct->shaderRoundingModeRTEFloat64;
shaderRoundingModeRTZFloat16 = in_struct->shaderRoundingModeRTZFloat16;
shaderRoundingModeRTZFloat32 = in_struct->shaderRoundingModeRTZFloat32;
shaderRoundingModeRTZFloat64 = in_struct->shaderRoundingModeRTZFloat64;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFloatControlsProperties::initialize(const safe_VkPhysicalDeviceFloatControlsProperties* copy_src)
{
sType = copy_src->sType;
denormBehaviorIndependence = copy_src->denormBehaviorIndependence;
roundingModeIndependence = copy_src->roundingModeIndependence;
shaderSignedZeroInfNanPreserveFloat16 = copy_src->shaderSignedZeroInfNanPreserveFloat16;
shaderSignedZeroInfNanPreserveFloat32 = copy_src->shaderSignedZeroInfNanPreserveFloat32;
shaderSignedZeroInfNanPreserveFloat64 = copy_src->shaderSignedZeroInfNanPreserveFloat64;
shaderDenormPreserveFloat16 = copy_src->shaderDenormPreserveFloat16;
shaderDenormPreserveFloat32 = copy_src->shaderDenormPreserveFloat32;
shaderDenormPreserveFloat64 = copy_src->shaderDenormPreserveFloat64;
shaderDenormFlushToZeroFloat16 = copy_src->shaderDenormFlushToZeroFloat16;
shaderDenormFlushToZeroFloat32 = copy_src->shaderDenormFlushToZeroFloat32;
shaderDenormFlushToZeroFloat64 = copy_src->shaderDenormFlushToZeroFloat64;
shaderRoundingModeRTEFloat16 = copy_src->shaderRoundingModeRTEFloat16;
shaderRoundingModeRTEFloat32 = copy_src->shaderRoundingModeRTEFloat32;
shaderRoundingModeRTEFloat64 = copy_src->shaderRoundingModeRTEFloat64;
shaderRoundingModeRTZFloat16 = copy_src->shaderRoundingModeRTZFloat16;
shaderRoundingModeRTZFloat32 = copy_src->shaderRoundingModeRTZFloat32;
shaderRoundingModeRTZFloat64 = copy_src->shaderRoundingModeRTZFloat64;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct) :
sType(in_struct->sType),
bindingCount(in_struct->bindingCount),
pBindingFlags(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pBindingFlags) {
pBindingFlags = new VkDescriptorBindingFlags[in_struct->bindingCount];
memcpy ((void *)pBindingFlags, (void *)in_struct->pBindingFlags, sizeof(VkDescriptorBindingFlags)*in_struct->bindingCount);
}
}
safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO),
pNext(nullptr),
pBindingFlags(nullptr)
{}
safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src)
{
sType = copy_src.sType;
bindingCount = copy_src.bindingCount;
pBindingFlags = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pBindingFlags) {
pBindingFlags = new VkDescriptorBindingFlags[copy_src.bindingCount];
memcpy ((void *)pBindingFlags, (void *)copy_src.pBindingFlags, sizeof(VkDescriptorBindingFlags)*copy_src.bindingCount);
}
}
safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::operator=(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pBindingFlags)
delete[] pBindingFlags;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
bindingCount = copy_src.bindingCount;
pBindingFlags = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pBindingFlags) {
pBindingFlags = new VkDescriptorBindingFlags[copy_src.bindingCount];
memcpy ((void *)pBindingFlags, (void *)copy_src.pBindingFlags, sizeof(VkDescriptorBindingFlags)*copy_src.bindingCount);
}
return *this;
}
safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::~safe_VkDescriptorSetLayoutBindingFlagsCreateInfo()
{
if (pBindingFlags)
delete[] pBindingFlags;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct)
{
sType = in_struct->sType;
bindingCount = in_struct->bindingCount;
pBindingFlags = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pBindingFlags) {
pBindingFlags = new VkDescriptorBindingFlags[in_struct->bindingCount];
memcpy ((void *)pBindingFlags, (void *)in_struct->pBindingFlags, sizeof(VkDescriptorBindingFlags)*in_struct->bindingCount);
}
}
void safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo* copy_src)
{
sType = copy_src->sType;
bindingCount = copy_src->bindingCount;
pBindingFlags = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pBindingFlags) {
pBindingFlags = new VkDescriptorBindingFlags[copy_src->bindingCount];
memcpy ((void *)pBindingFlags, (void *)copy_src->pBindingFlags, sizeof(VkDescriptorBindingFlags)*copy_src->bindingCount);
}
}
safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct) :
sType(in_struct->sType),
shaderInputAttachmentArrayDynamicIndexing(in_struct->shaderInputAttachmentArrayDynamicIndexing),
shaderUniformTexelBufferArrayDynamicIndexing(in_struct->shaderUniformTexelBufferArrayDynamicIndexing),
shaderStorageTexelBufferArrayDynamicIndexing(in_struct->shaderStorageTexelBufferArrayDynamicIndexing),
shaderUniformBufferArrayNonUniformIndexing(in_struct->shaderUniformBufferArrayNonUniformIndexing),
shaderSampledImageArrayNonUniformIndexing(in_struct->shaderSampledImageArrayNonUniformIndexing),
shaderStorageBufferArrayNonUniformIndexing(in_struct->shaderStorageBufferArrayNonUniformIndexing),
shaderStorageImageArrayNonUniformIndexing(in_struct->shaderStorageImageArrayNonUniformIndexing),
shaderInputAttachmentArrayNonUniformIndexing(in_struct->shaderInputAttachmentArrayNonUniformIndexing),
shaderUniformTexelBufferArrayNonUniformIndexing(in_struct->shaderUniformTexelBufferArrayNonUniformIndexing),
shaderStorageTexelBufferArrayNonUniformIndexing(in_struct->shaderStorageTexelBufferArrayNonUniformIndexing),
descriptorBindingUniformBufferUpdateAfterBind(in_struct->descriptorBindingUniformBufferUpdateAfterBind),
descriptorBindingSampledImageUpdateAfterBind(in_struct->descriptorBindingSampledImageUpdateAfterBind),
descriptorBindingStorageImageUpdateAfterBind(in_struct->descriptorBindingStorageImageUpdateAfterBind),
descriptorBindingStorageBufferUpdateAfterBind(in_struct->descriptorBindingStorageBufferUpdateAfterBind),
descriptorBindingUniformTexelBufferUpdateAfterBind(in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind),
descriptorBindingStorageTexelBufferUpdateAfterBind(in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind),
descriptorBindingUpdateUnusedWhilePending(in_struct->descriptorBindingUpdateUnusedWhilePending),
descriptorBindingPartiallyBound(in_struct->descriptorBindingPartiallyBound),
descriptorBindingVariableDescriptorCount(in_struct->descriptorBindingVariableDescriptorCount),
runtimeDescriptorArray(in_struct->runtimeDescriptorArray)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src)
{
sType = copy_src.sType;
shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing;
shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing;
shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing;
shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing;
shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing;
shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing;
shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing;
shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing;
shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing;
shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing;
descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind;
descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind;
descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind;
descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind;
descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind;
descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind;
descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending;
descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound;
descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount;
runtimeDescriptorArray = copy_src.runtimeDescriptorArray;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDescriptorIndexingFeatures& safe_VkPhysicalDeviceDescriptorIndexingFeatures::operator=(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing;
shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing;
shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing;
shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing;
shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing;
shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing;
shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing;
shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing;
shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing;
shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing;
descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind;
descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind;
descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind;
descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind;
descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind;
descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind;
descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending;
descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound;
descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount;
runtimeDescriptorArray = copy_src.runtimeDescriptorArray;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDescriptorIndexingFeatures::~safe_VkPhysicalDeviceDescriptorIndexingFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDescriptorIndexingFeatures::initialize(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct)
{
sType = in_struct->sType;
shaderInputAttachmentArrayDynamicIndexing = in_struct->shaderInputAttachmentArrayDynamicIndexing;
shaderUniformTexelBufferArrayDynamicIndexing = in_struct->shaderUniformTexelBufferArrayDynamicIndexing;
shaderStorageTexelBufferArrayDynamicIndexing = in_struct->shaderStorageTexelBufferArrayDynamicIndexing;
shaderUniformBufferArrayNonUniformIndexing = in_struct->shaderUniformBufferArrayNonUniformIndexing;
shaderSampledImageArrayNonUniformIndexing = in_struct->shaderSampledImageArrayNonUniformIndexing;
shaderStorageBufferArrayNonUniformIndexing = in_struct->shaderStorageBufferArrayNonUniformIndexing;
shaderStorageImageArrayNonUniformIndexing = in_struct->shaderStorageImageArrayNonUniformIndexing;
shaderInputAttachmentArrayNonUniformIndexing = in_struct->shaderInputAttachmentArrayNonUniformIndexing;
shaderUniformTexelBufferArrayNonUniformIndexing = in_struct->shaderUniformTexelBufferArrayNonUniformIndexing;
shaderStorageTexelBufferArrayNonUniformIndexing = in_struct->shaderStorageTexelBufferArrayNonUniformIndexing;
descriptorBindingUniformBufferUpdateAfterBind = in_struct->descriptorBindingUniformBufferUpdateAfterBind;
descriptorBindingSampledImageUpdateAfterBind = in_struct->descriptorBindingSampledImageUpdateAfterBind;
descriptorBindingStorageImageUpdateAfterBind = in_struct->descriptorBindingStorageImageUpdateAfterBind;
descriptorBindingStorageBufferUpdateAfterBind = in_struct->descriptorBindingStorageBufferUpdateAfterBind;
descriptorBindingUniformTexelBufferUpdateAfterBind = in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind;
descriptorBindingStorageTexelBufferUpdateAfterBind = in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind;
descriptorBindingUpdateUnusedWhilePending = in_struct->descriptorBindingUpdateUnusedWhilePending;
descriptorBindingPartiallyBound = in_struct->descriptorBindingPartiallyBound;
descriptorBindingVariableDescriptorCount = in_struct->descriptorBindingVariableDescriptorCount;
runtimeDescriptorArray = in_struct->runtimeDescriptorArray;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDescriptorIndexingFeatures::initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeatures* copy_src)
{
sType = copy_src->sType;
shaderInputAttachmentArrayDynamicIndexing = copy_src->shaderInputAttachmentArrayDynamicIndexing;
shaderUniformTexelBufferArrayDynamicIndexing = copy_src->shaderUniformTexelBufferArrayDynamicIndexing;
shaderStorageTexelBufferArrayDynamicIndexing = copy_src->shaderStorageTexelBufferArrayDynamicIndexing;
shaderUniformBufferArrayNonUniformIndexing = copy_src->shaderUniformBufferArrayNonUniformIndexing;
shaderSampledImageArrayNonUniformIndexing = copy_src->shaderSampledImageArrayNonUniformIndexing;
shaderStorageBufferArrayNonUniformIndexing = copy_src->shaderStorageBufferArrayNonUniformIndexing;
shaderStorageImageArrayNonUniformIndexing = copy_src->shaderStorageImageArrayNonUniformIndexing;
shaderInputAttachmentArrayNonUniformIndexing = copy_src->shaderInputAttachmentArrayNonUniformIndexing;
shaderUniformTexelBufferArrayNonUniformIndexing = copy_src->shaderUniformTexelBufferArrayNonUniformIndexing;
shaderStorageTexelBufferArrayNonUniformIndexing = copy_src->shaderStorageTexelBufferArrayNonUniformIndexing;
descriptorBindingUniformBufferUpdateAfterBind = copy_src->descriptorBindingUniformBufferUpdateAfterBind;
descriptorBindingSampledImageUpdateAfterBind = copy_src->descriptorBindingSampledImageUpdateAfterBind;
descriptorBindingStorageImageUpdateAfterBind = copy_src->descriptorBindingStorageImageUpdateAfterBind;
descriptorBindingStorageBufferUpdateAfterBind = copy_src->descriptorBindingStorageBufferUpdateAfterBind;
descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src->descriptorBindingUniformTexelBufferUpdateAfterBind;
descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src->descriptorBindingStorageTexelBufferUpdateAfterBind;
descriptorBindingUpdateUnusedWhilePending = copy_src->descriptorBindingUpdateUnusedWhilePending;
descriptorBindingPartiallyBound = copy_src->descriptorBindingPartiallyBound;
descriptorBindingVariableDescriptorCount = copy_src->descriptorBindingVariableDescriptorCount;
runtimeDescriptorArray = copy_src->runtimeDescriptorArray;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct) :
sType(in_struct->sType),
maxUpdateAfterBindDescriptorsInAllPools(in_struct->maxUpdateAfterBindDescriptorsInAllPools),
shaderUniformBufferArrayNonUniformIndexingNative(in_struct->shaderUniformBufferArrayNonUniformIndexingNative),
shaderSampledImageArrayNonUniformIndexingNative(in_struct->shaderSampledImageArrayNonUniformIndexingNative),
shaderStorageBufferArrayNonUniformIndexingNative(in_struct->shaderStorageBufferArrayNonUniformIndexingNative),
shaderStorageImageArrayNonUniformIndexingNative(in_struct->shaderStorageImageArrayNonUniformIndexingNative),
shaderInputAttachmentArrayNonUniformIndexingNative(in_struct->shaderInputAttachmentArrayNonUniformIndexingNative),
robustBufferAccessUpdateAfterBind(in_struct->robustBufferAccessUpdateAfterBind),
quadDivergentImplicitLod(in_struct->quadDivergentImplicitLod),
maxPerStageDescriptorUpdateAfterBindSamplers(in_struct->maxPerStageDescriptorUpdateAfterBindSamplers),
maxPerStageDescriptorUpdateAfterBindUniformBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers),
maxPerStageDescriptorUpdateAfterBindStorageBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers),
maxPerStageDescriptorUpdateAfterBindSampledImages(in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages),
maxPerStageDescriptorUpdateAfterBindStorageImages(in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages),
maxPerStageDescriptorUpdateAfterBindInputAttachments(in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments),
maxPerStageUpdateAfterBindResources(in_struct->maxPerStageUpdateAfterBindResources),
maxDescriptorSetUpdateAfterBindSamplers(in_struct->maxDescriptorSetUpdateAfterBindSamplers),
maxDescriptorSetUpdateAfterBindUniformBuffers(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers),
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),
maxDescriptorSetUpdateAfterBindStorageBuffers(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers),
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),
maxDescriptorSetUpdateAfterBindSampledImages(in_struct->maxDescriptorSetUpdateAfterBindSampledImages),
maxDescriptorSetUpdateAfterBindStorageImages(in_struct->maxDescriptorSetUpdateAfterBindStorageImages),
maxDescriptorSetUpdateAfterBindInputAttachments(in_struct->maxDescriptorSetUpdateAfterBindInputAttachments)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src)
{
sType = copy_src.sType;
maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools;
shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative;
shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative;
shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative;
shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative;
shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative;
robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind;
quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod;
maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers;
maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages;
maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages;
maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments;
maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources;
maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers;
maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers;
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers;
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages;
maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages;
maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDescriptorIndexingProperties& safe_VkPhysicalDeviceDescriptorIndexingProperties::operator=(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools;
shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative;
shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative;
shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative;
shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative;
shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative;
robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind;
quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod;
maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers;
maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages;
maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages;
maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments;
maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources;
maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers;
maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers;
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers;
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages;
maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages;
maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDescriptorIndexingProperties::~safe_VkPhysicalDeviceDescriptorIndexingProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDescriptorIndexingProperties::initialize(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct)
{
sType = in_struct->sType;
maxUpdateAfterBindDescriptorsInAllPools = in_struct->maxUpdateAfterBindDescriptorsInAllPools;
shaderUniformBufferArrayNonUniformIndexingNative = in_struct->shaderUniformBufferArrayNonUniformIndexingNative;
shaderSampledImageArrayNonUniformIndexingNative = in_struct->shaderSampledImageArrayNonUniformIndexingNative;
shaderStorageBufferArrayNonUniformIndexingNative = in_struct->shaderStorageBufferArrayNonUniformIndexingNative;
shaderStorageImageArrayNonUniformIndexingNative = in_struct->shaderStorageImageArrayNonUniformIndexingNative;
shaderInputAttachmentArrayNonUniformIndexingNative = in_struct->shaderInputAttachmentArrayNonUniformIndexingNative;
robustBufferAccessUpdateAfterBind = in_struct->robustBufferAccessUpdateAfterBind;
quadDivergentImplicitLod = in_struct->quadDivergentImplicitLod;
maxPerStageDescriptorUpdateAfterBindSamplers = in_struct->maxPerStageDescriptorUpdateAfterBindSamplers;
maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
maxPerStageDescriptorUpdateAfterBindSampledImages = in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages;
maxPerStageDescriptorUpdateAfterBindStorageImages = in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages;
maxPerStageDescriptorUpdateAfterBindInputAttachments = in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments;
maxPerStageUpdateAfterBindResources = in_struct->maxPerStageUpdateAfterBindResources;
maxDescriptorSetUpdateAfterBindSamplers = in_struct->maxDescriptorSetUpdateAfterBindSamplers;
maxDescriptorSetUpdateAfterBindUniformBuffers = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers;
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
maxDescriptorSetUpdateAfterBindStorageBuffers = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers;
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
maxDescriptorSetUpdateAfterBindSampledImages = in_struct->maxDescriptorSetUpdateAfterBindSampledImages;
maxDescriptorSetUpdateAfterBindStorageImages = in_struct->maxDescriptorSetUpdateAfterBindStorageImages;
maxDescriptorSetUpdateAfterBindInputAttachments = in_struct->maxDescriptorSetUpdateAfterBindInputAttachments;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDescriptorIndexingProperties::initialize(const safe_VkPhysicalDeviceDescriptorIndexingProperties* copy_src)
{
sType = copy_src->sType;
maxUpdateAfterBindDescriptorsInAllPools = copy_src->maxUpdateAfterBindDescriptorsInAllPools;
shaderUniformBufferArrayNonUniformIndexingNative = copy_src->shaderUniformBufferArrayNonUniformIndexingNative;
shaderSampledImageArrayNonUniformIndexingNative = copy_src->shaderSampledImageArrayNonUniformIndexingNative;
shaderStorageBufferArrayNonUniformIndexingNative = copy_src->shaderStorageBufferArrayNonUniformIndexingNative;
shaderStorageImageArrayNonUniformIndexingNative = copy_src->shaderStorageImageArrayNonUniformIndexingNative;
shaderInputAttachmentArrayNonUniformIndexingNative = copy_src->shaderInputAttachmentArrayNonUniformIndexingNative;
robustBufferAccessUpdateAfterBind = copy_src->robustBufferAccessUpdateAfterBind;
quadDivergentImplicitLod = copy_src->quadDivergentImplicitLod;
maxPerStageDescriptorUpdateAfterBindSamplers = copy_src->maxPerStageDescriptorUpdateAfterBindSamplers;
maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src->maxPerStageDescriptorUpdateAfterBindSampledImages;
maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src->maxPerStageDescriptorUpdateAfterBindStorageImages;
maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src->maxPerStageDescriptorUpdateAfterBindInputAttachments;
maxPerStageUpdateAfterBindResources = copy_src->maxPerStageUpdateAfterBindResources;
maxDescriptorSetUpdateAfterBindSamplers = copy_src->maxDescriptorSetUpdateAfterBindSamplers;
maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffers;
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffers;
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
maxDescriptorSetUpdateAfterBindSampledImages = copy_src->maxDescriptorSetUpdateAfterBindSampledImages;
maxDescriptorSetUpdateAfterBindStorageImages = copy_src->maxDescriptorSetUpdateAfterBindStorageImages;
maxDescriptorSetUpdateAfterBindInputAttachments = copy_src->maxDescriptorSetUpdateAfterBindInputAttachments;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct) :
sType(in_struct->sType),
descriptorSetCount(in_struct->descriptorSetCount),
pDescriptorCounts(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDescriptorCounts) {
pDescriptorCounts = new uint32_t[in_struct->descriptorSetCount];
memcpy ((void *)pDescriptorCounts, (void *)in_struct->pDescriptorCounts, sizeof(uint32_t)*in_struct->descriptorSetCount);
}
}
safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO),
pNext(nullptr),
pDescriptorCounts(nullptr)
{}
safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src)
{
sType = copy_src.sType;
descriptorSetCount = copy_src.descriptorSetCount;
pDescriptorCounts = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDescriptorCounts) {
pDescriptorCounts = new uint32_t[copy_src.descriptorSetCount];
memcpy ((void *)pDescriptorCounts, (void *)copy_src.pDescriptorCounts, sizeof(uint32_t)*copy_src.descriptorSetCount);
}
}
safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::operator=(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pDescriptorCounts)
delete[] pDescriptorCounts;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
descriptorSetCount = copy_src.descriptorSetCount;
pDescriptorCounts = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDescriptorCounts) {
pDescriptorCounts = new uint32_t[copy_src.descriptorSetCount];
memcpy ((void *)pDescriptorCounts, (void *)copy_src.pDescriptorCounts, sizeof(uint32_t)*copy_src.descriptorSetCount);
}
return *this;
}
safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::~safe_VkDescriptorSetVariableDescriptorCountAllocateInfo()
{
if (pDescriptorCounts)
delete[] pDescriptorCounts;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::initialize(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct)
{
sType = in_struct->sType;
descriptorSetCount = in_struct->descriptorSetCount;
pDescriptorCounts = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDescriptorCounts) {
pDescriptorCounts = new uint32_t[in_struct->descriptorSetCount];
memcpy ((void *)pDescriptorCounts, (void *)in_struct->pDescriptorCounts, sizeof(uint32_t)*in_struct->descriptorSetCount);
}
}
void safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::initialize(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo* copy_src)
{
sType = copy_src->sType;
descriptorSetCount = copy_src->descriptorSetCount;
pDescriptorCounts = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDescriptorCounts) {
pDescriptorCounts = new uint32_t[copy_src->descriptorSetCount];
memcpy ((void *)pDescriptorCounts, (void *)copy_src->pDescriptorCounts, sizeof(uint32_t)*copy_src->descriptorSetCount);
}
}
safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct) :
sType(in_struct->sType),
maxVariableDescriptorCount(in_struct->maxVariableDescriptorCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT),
pNext(nullptr)
{}
safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src)
{
sType = copy_src.sType;
maxVariableDescriptorCount = copy_src.maxVariableDescriptorCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::operator=(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxVariableDescriptorCount = copy_src.maxVariableDescriptorCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::~safe_VkDescriptorSetVariableDescriptorCountLayoutSupport()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::initialize(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct)
{
sType = in_struct->sType;
maxVariableDescriptorCount = in_struct->maxVariableDescriptorCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::initialize(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport* copy_src)
{
sType = copy_src->sType;
maxVariableDescriptorCount = copy_src->maxVariableDescriptorCount;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve* in_struct) :
sType(in_struct->sType),
depthResolveMode(in_struct->depthResolveMode),
stencilResolveMode(in_struct->stencilResolveMode),
pDepthStencilResolveAttachment(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDepthStencilResolveAttachment)
pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilResolveAttachment);
}
safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve() :
sType(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE),
pNext(nullptr),
pDepthStencilResolveAttachment(nullptr)
{}
safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src)
{
sType = copy_src.sType;
depthResolveMode = copy_src.depthResolveMode;
stencilResolveMode = copy_src.stencilResolveMode;
pDepthStencilResolveAttachment = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDepthStencilResolveAttachment)
pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilResolveAttachment);
}
safe_VkSubpassDescriptionDepthStencilResolve& safe_VkSubpassDescriptionDepthStencilResolve::operator=(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src)
{
if (&copy_src == this) return *this;
if (pDepthStencilResolveAttachment)
delete pDepthStencilResolveAttachment;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
depthResolveMode = copy_src.depthResolveMode;
stencilResolveMode = copy_src.stencilResolveMode;
pDepthStencilResolveAttachment = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDepthStencilResolveAttachment)
pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilResolveAttachment);
return *this;
}
safe_VkSubpassDescriptionDepthStencilResolve::~safe_VkSubpassDescriptionDepthStencilResolve()
{
if (pDepthStencilResolveAttachment)
delete pDepthStencilResolveAttachment;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSubpassDescriptionDepthStencilResolve::initialize(const VkSubpassDescriptionDepthStencilResolve* in_struct)
{
sType = in_struct->sType;
depthResolveMode = in_struct->depthResolveMode;
stencilResolveMode = in_struct->stencilResolveMode;
pDepthStencilResolveAttachment = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDepthStencilResolveAttachment)
pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilResolveAttachment);
}
void safe_VkSubpassDescriptionDepthStencilResolve::initialize(const safe_VkSubpassDescriptionDepthStencilResolve* copy_src)
{
sType = copy_src->sType;
depthResolveMode = copy_src->depthResolveMode;
stencilResolveMode = copy_src->stencilResolveMode;
pDepthStencilResolveAttachment = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDepthStencilResolveAttachment)
pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src->pDepthStencilResolveAttachment);
}
safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct) :
sType(in_struct->sType),
supportedDepthResolveModes(in_struct->supportedDepthResolveModes),
supportedStencilResolveModes(in_struct->supportedStencilResolveModes),
independentResolveNone(in_struct->independentResolveNone),
independentResolve(in_struct->independentResolve)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties(const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src)
{
sType = copy_src.sType;
supportedDepthResolveModes = copy_src.supportedDepthResolveModes;
supportedStencilResolveModes = copy_src.supportedStencilResolveModes;
independentResolveNone = copy_src.independentResolveNone;
independentResolve = copy_src.independentResolve;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDepthStencilResolveProperties& safe_VkPhysicalDeviceDepthStencilResolveProperties::operator=(const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
supportedDepthResolveModes = copy_src.supportedDepthResolveModes;
supportedStencilResolveModes = copy_src.supportedStencilResolveModes;
independentResolveNone = copy_src.independentResolveNone;
independentResolve = copy_src.independentResolve;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDepthStencilResolveProperties::~safe_VkPhysicalDeviceDepthStencilResolveProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDepthStencilResolveProperties::initialize(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct)
{
sType = in_struct->sType;
supportedDepthResolveModes = in_struct->supportedDepthResolveModes;
supportedStencilResolveModes = in_struct->supportedStencilResolveModes;
independentResolveNone = in_struct->independentResolveNone;
independentResolve = in_struct->independentResolve;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDepthStencilResolveProperties::initialize(const safe_VkPhysicalDeviceDepthStencilResolveProperties* copy_src)
{
sType = copy_src->sType;
supportedDepthResolveModes = copy_src->supportedDepthResolveModes;
supportedStencilResolveModes = copy_src->supportedStencilResolveModes;
independentResolveNone = copy_src->independentResolveNone;
independentResolve = copy_src->independentResolve;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct) :
sType(in_struct->sType),
scalarBlockLayout(in_struct->scalarBlockLayout)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src)
{
sType = copy_src.sType;
scalarBlockLayout = copy_src.scalarBlockLayout;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceScalarBlockLayoutFeatures& safe_VkPhysicalDeviceScalarBlockLayoutFeatures::operator=(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
scalarBlockLayout = copy_src.scalarBlockLayout;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceScalarBlockLayoutFeatures::~safe_VkPhysicalDeviceScalarBlockLayoutFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceScalarBlockLayoutFeatures::initialize(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct)
{
sType = in_struct->sType;
scalarBlockLayout = in_struct->scalarBlockLayout;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceScalarBlockLayoutFeatures::initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures* copy_src)
{
sType = copy_src->sType;
scalarBlockLayout = copy_src->scalarBlockLayout;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* in_struct) :
sType(in_struct->sType),
stencilUsage(in_struct->stencilUsage)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo() :
sType(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo(const safe_VkImageStencilUsageCreateInfo& copy_src)
{
sType = copy_src.sType;
stencilUsage = copy_src.stencilUsage;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageStencilUsageCreateInfo& safe_VkImageStencilUsageCreateInfo::operator=(const safe_VkImageStencilUsageCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stencilUsage = copy_src.stencilUsage;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageStencilUsageCreateInfo::~safe_VkImageStencilUsageCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageStencilUsageCreateInfo::initialize(const VkImageStencilUsageCreateInfo* in_struct)
{
sType = in_struct->sType;
stencilUsage = in_struct->stencilUsage;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageStencilUsageCreateInfo::initialize(const safe_VkImageStencilUsageCreateInfo* copy_src)
{
sType = copy_src->sType;
stencilUsage = copy_src->stencilUsage;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* in_struct) :
sType(in_struct->sType),
reductionMode(in_struct->reductionMode)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo() :
sType(VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo(const safe_VkSamplerReductionModeCreateInfo& copy_src)
{
sType = copy_src.sType;
reductionMode = copy_src.reductionMode;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSamplerReductionModeCreateInfo& safe_VkSamplerReductionModeCreateInfo::operator=(const safe_VkSamplerReductionModeCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
reductionMode = copy_src.reductionMode;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSamplerReductionModeCreateInfo::~safe_VkSamplerReductionModeCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSamplerReductionModeCreateInfo::initialize(const VkSamplerReductionModeCreateInfo* in_struct)
{
sType = in_struct->sType;
reductionMode = in_struct->reductionMode;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSamplerReductionModeCreateInfo::initialize(const safe_VkSamplerReductionModeCreateInfo* copy_src)
{
sType = copy_src->sType;
reductionMode = copy_src->reductionMode;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct) :
sType(in_struct->sType),
filterMinmaxSingleComponentFormats(in_struct->filterMinmaxSingleComponentFormats),
filterMinmaxImageComponentMapping(in_struct->filterMinmaxImageComponentMapping)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src)
{
sType = copy_src.sType;
filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::operator=(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::~safe_VkPhysicalDeviceSamplerFilterMinmaxProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::initialize(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct)
{
sType = in_struct->sType;
filterMinmaxSingleComponentFormats = in_struct->filterMinmaxSingleComponentFormats;
filterMinmaxImageComponentMapping = in_struct->filterMinmaxImageComponentMapping;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties* copy_src)
{
sType = copy_src->sType;
filterMinmaxSingleComponentFormats = copy_src->filterMinmaxSingleComponentFormats;
filterMinmaxImageComponentMapping = copy_src->filterMinmaxImageComponentMapping;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct) :
sType(in_struct->sType),
vulkanMemoryModel(in_struct->vulkanMemoryModel),
vulkanMemoryModelDeviceScope(in_struct->vulkanMemoryModelDeviceScope),
vulkanMemoryModelAvailabilityVisibilityChains(in_struct->vulkanMemoryModelAvailabilityVisibilityChains)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src)
{
sType = copy_src.sType;
vulkanMemoryModel = copy_src.vulkanMemoryModel;
vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceVulkanMemoryModelFeatures& safe_VkPhysicalDeviceVulkanMemoryModelFeatures::operator=(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
vulkanMemoryModel = copy_src.vulkanMemoryModel;
vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceVulkanMemoryModelFeatures::~safe_VkPhysicalDeviceVulkanMemoryModelFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVulkanMemoryModelFeatures::initialize(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct)
{
sType = in_struct->sType;
vulkanMemoryModel = in_struct->vulkanMemoryModel;
vulkanMemoryModelDeviceScope = in_struct->vulkanMemoryModelDeviceScope;
vulkanMemoryModelAvailabilityVisibilityChains = in_struct->vulkanMemoryModelAvailabilityVisibilityChains;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceVulkanMemoryModelFeatures::initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures* copy_src)
{
sType = copy_src->sType;
vulkanMemoryModel = copy_src->vulkanMemoryModel;
vulkanMemoryModelDeviceScope = copy_src->vulkanMemoryModelDeviceScope;
vulkanMemoryModelAvailabilityVisibilityChains = copy_src->vulkanMemoryModelAvailabilityVisibilityChains;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct) :
sType(in_struct->sType),
imagelessFramebuffer(in_struct->imagelessFramebuffer)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src)
{
sType = copy_src.sType;
imagelessFramebuffer = copy_src.imagelessFramebuffer;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceImagelessFramebufferFeatures& safe_VkPhysicalDeviceImagelessFramebufferFeatures::operator=(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
imagelessFramebuffer = copy_src.imagelessFramebuffer;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceImagelessFramebufferFeatures::~safe_VkPhysicalDeviceImagelessFramebufferFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceImagelessFramebufferFeatures::initialize(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct)
{
sType = in_struct->sType;
imagelessFramebuffer = in_struct->imagelessFramebuffer;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceImagelessFramebufferFeatures::initialize(const safe_VkPhysicalDeviceImagelessFramebufferFeatures* copy_src)
{
sType = copy_src->sType;
imagelessFramebuffer = copy_src->imagelessFramebuffer;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
usage(in_struct->usage),
width(in_struct->width),
height(in_struct->height),
layerCount(in_struct->layerCount),
viewFormatCount(in_struct->viewFormatCount),
pViewFormats(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewFormats) {
pViewFormats = new VkFormat[in_struct->viewFormatCount];
memcpy ((void *)pViewFormats, (void *)in_struct->pViewFormats, sizeof(VkFormat)*in_struct->viewFormatCount);
}
}
safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo() :
sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO),
pNext(nullptr),
pViewFormats(nullptr)
{}
safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo(const safe_VkFramebufferAttachmentImageInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
usage = copy_src.usage;
width = copy_src.width;
height = copy_src.height;
layerCount = copy_src.layerCount;
viewFormatCount = copy_src.viewFormatCount;
pViewFormats = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewFormats) {
pViewFormats = new VkFormat[copy_src.viewFormatCount];
memcpy ((void *)pViewFormats, (void *)copy_src.pViewFormats, sizeof(VkFormat)*copy_src.viewFormatCount);
}
}
safe_VkFramebufferAttachmentImageInfo& safe_VkFramebufferAttachmentImageInfo::operator=(const safe_VkFramebufferAttachmentImageInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pViewFormats)
delete[] pViewFormats;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
usage = copy_src.usage;
width = copy_src.width;
height = copy_src.height;
layerCount = copy_src.layerCount;
viewFormatCount = copy_src.viewFormatCount;
pViewFormats = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewFormats) {
pViewFormats = new VkFormat[copy_src.viewFormatCount];
memcpy ((void *)pViewFormats, (void *)copy_src.pViewFormats, sizeof(VkFormat)*copy_src.viewFormatCount);
}
return *this;
}
safe_VkFramebufferAttachmentImageInfo::~safe_VkFramebufferAttachmentImageInfo()
{
if (pViewFormats)
delete[] pViewFormats;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFramebufferAttachmentImageInfo::initialize(const VkFramebufferAttachmentImageInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
usage = in_struct->usage;
width = in_struct->width;
height = in_struct->height;
layerCount = in_struct->layerCount;
viewFormatCount = in_struct->viewFormatCount;
pViewFormats = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewFormats) {
pViewFormats = new VkFormat[in_struct->viewFormatCount];
memcpy ((void *)pViewFormats, (void *)in_struct->pViewFormats, sizeof(VkFormat)*in_struct->viewFormatCount);
}
}
void safe_VkFramebufferAttachmentImageInfo::initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
usage = copy_src->usage;
width = copy_src->width;
height = copy_src->height;
layerCount = copy_src->layerCount;
viewFormatCount = copy_src->viewFormatCount;
pViewFormats = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pViewFormats) {
pViewFormats = new VkFormat[copy_src->viewFormatCount];
memcpy ((void *)pViewFormats, (void *)copy_src->pViewFormats, sizeof(VkFormat)*copy_src->viewFormatCount);
}
}
safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo* in_struct) :
sType(in_struct->sType),
attachmentImageInfoCount(in_struct->attachmentImageInfoCount),
pAttachmentImageInfos(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (attachmentImageInfoCount && in_struct->pAttachmentImageInfos) {
pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]);
}
}
}
safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo() :
sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO),
pNext(nullptr),
pAttachmentImageInfos(nullptr)
{}
safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo(const safe_VkFramebufferAttachmentsCreateInfo& copy_src)
{
sType = copy_src.sType;
attachmentImageInfoCount = copy_src.attachmentImageInfoCount;
pAttachmentImageInfos = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (attachmentImageInfoCount && copy_src.pAttachmentImageInfos) {
pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
pAttachmentImageInfos[i].initialize(&copy_src.pAttachmentImageInfos[i]);
}
}
}
safe_VkFramebufferAttachmentsCreateInfo& safe_VkFramebufferAttachmentsCreateInfo::operator=(const safe_VkFramebufferAttachmentsCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pAttachmentImageInfos)
delete[] pAttachmentImageInfos;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
attachmentImageInfoCount = copy_src.attachmentImageInfoCount;
pAttachmentImageInfos = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (attachmentImageInfoCount && copy_src.pAttachmentImageInfos) {
pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
pAttachmentImageInfos[i].initialize(&copy_src.pAttachmentImageInfos[i]);
}
}
return *this;
}
safe_VkFramebufferAttachmentsCreateInfo::~safe_VkFramebufferAttachmentsCreateInfo()
{
if (pAttachmentImageInfos)
delete[] pAttachmentImageInfos;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFramebufferAttachmentsCreateInfo::initialize(const VkFramebufferAttachmentsCreateInfo* in_struct)
{
sType = in_struct->sType;
attachmentImageInfoCount = in_struct->attachmentImageInfoCount;
pAttachmentImageInfos = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (attachmentImageInfoCount && in_struct->pAttachmentImageInfos) {
pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]);
}
}
}
void safe_VkFramebufferAttachmentsCreateInfo::initialize(const safe_VkFramebufferAttachmentsCreateInfo* copy_src)
{
sType = copy_src->sType;
attachmentImageInfoCount = copy_src->attachmentImageInfoCount;
pAttachmentImageInfos = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (attachmentImageInfoCount && copy_src->pAttachmentImageInfos) {
pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
pAttachmentImageInfos[i].initialize(&copy_src->pAttachmentImageInfos[i]);
}
}
}
safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct) :
sType(in_struct->sType),
attachmentCount(in_struct->attachmentCount),
pAttachments(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (attachmentCount && in_struct->pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = in_struct->pAttachments[i];
}
}
}
safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO),
pNext(nullptr),
pAttachments(nullptr)
{}
safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src)
{
sType = copy_src.sType;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (attachmentCount && copy_src.pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = copy_src.pAttachments[i];
}
}
}
safe_VkRenderPassAttachmentBeginInfo& safe_VkRenderPassAttachmentBeginInfo::operator=(const safe_VkRenderPassAttachmentBeginInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pAttachments)
delete[] pAttachments;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
attachmentCount = copy_src.attachmentCount;
pAttachments = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (attachmentCount && copy_src.pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = copy_src.pAttachments[i];
}
}
return *this;
}
safe_VkRenderPassAttachmentBeginInfo::~safe_VkRenderPassAttachmentBeginInfo()
{
if (pAttachments)
delete[] pAttachments;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassAttachmentBeginInfo::initialize(const VkRenderPassAttachmentBeginInfo* in_struct)
{
sType = in_struct->sType;
attachmentCount = in_struct->attachmentCount;
pAttachments = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (attachmentCount && in_struct->pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = in_struct->pAttachments[i];
}
}
}
void safe_VkRenderPassAttachmentBeginInfo::initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src)
{
sType = copy_src->sType;
attachmentCount = copy_src->attachmentCount;
pAttachments = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (attachmentCount && copy_src->pAttachments) {
pAttachments = new VkImageView[attachmentCount];
for (uint32_t i = 0; i < attachmentCount; ++i) {
pAttachments[i] = copy_src->pAttachments[i];
}
}
}
safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct) :
sType(in_struct->sType),
uniformBufferStandardLayout(in_struct->uniformBufferStandardLayout)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src)
{
sType = copy_src.sType;
uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::operator=(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct)
{
sType = in_struct->sType;
uniformBufferStandardLayout = in_struct->uniformBufferStandardLayout;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::initialize(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src)
{
sType = copy_src->sType;
uniformBufferStandardLayout = copy_src->uniformBufferStandardLayout;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct) :
sType(in_struct->sType),
shaderSubgroupExtendedTypes(in_struct->shaderSubgroupExtendedTypes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src)
{
sType = copy_src.sType;
shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::operator=(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::~safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::initialize(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct)
{
sType = in_struct->sType;
shaderSubgroupExtendedTypes = in_struct->shaderSubgroupExtendedTypes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::initialize(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src)
{
sType = copy_src->sType;
shaderSubgroupExtendedTypes = copy_src->shaderSubgroupExtendedTypes;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct) :
sType(in_struct->sType),
separateDepthStencilLayouts(in_struct->separateDepthStencilLayouts)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src)
{
sType = copy_src.sType;
separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::operator=(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::~safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::initialize(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct)
{
sType = in_struct->sType;
separateDepthStencilLayouts = in_struct->separateDepthStencilLayouts;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::initialize(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src)
{
sType = copy_src->sType;
separateDepthStencilLayouts = copy_src->separateDepthStencilLayouts;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout* in_struct) :
sType(in_struct->sType),
stencilLayout(in_struct->stencilLayout)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout() :
sType(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT),
pNext(nullptr)
{}
safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout(const safe_VkAttachmentReferenceStencilLayout& copy_src)
{
sType = copy_src.sType;
stencilLayout = copy_src.stencilLayout;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAttachmentReferenceStencilLayout& safe_VkAttachmentReferenceStencilLayout::operator=(const safe_VkAttachmentReferenceStencilLayout& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stencilLayout = copy_src.stencilLayout;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAttachmentReferenceStencilLayout::~safe_VkAttachmentReferenceStencilLayout()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAttachmentReferenceStencilLayout::initialize(const VkAttachmentReferenceStencilLayout* in_struct)
{
sType = in_struct->sType;
stencilLayout = in_struct->stencilLayout;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAttachmentReferenceStencilLayout::initialize(const safe_VkAttachmentReferenceStencilLayout* copy_src)
{
sType = copy_src->sType;
stencilLayout = copy_src->stencilLayout;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout* in_struct) :
sType(in_struct->sType),
stencilInitialLayout(in_struct->stencilInitialLayout),
stencilFinalLayout(in_struct->stencilFinalLayout)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout() :
sType(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT),
pNext(nullptr)
{}
safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout(const safe_VkAttachmentDescriptionStencilLayout& copy_src)
{
sType = copy_src.sType;
stencilInitialLayout = copy_src.stencilInitialLayout;
stencilFinalLayout = copy_src.stencilFinalLayout;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAttachmentDescriptionStencilLayout& safe_VkAttachmentDescriptionStencilLayout::operator=(const safe_VkAttachmentDescriptionStencilLayout& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stencilInitialLayout = copy_src.stencilInitialLayout;
stencilFinalLayout = copy_src.stencilFinalLayout;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAttachmentDescriptionStencilLayout::~safe_VkAttachmentDescriptionStencilLayout()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAttachmentDescriptionStencilLayout::initialize(const VkAttachmentDescriptionStencilLayout* in_struct)
{
sType = in_struct->sType;
stencilInitialLayout = in_struct->stencilInitialLayout;
stencilFinalLayout = in_struct->stencilFinalLayout;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAttachmentDescriptionStencilLayout::initialize(const safe_VkAttachmentDescriptionStencilLayout* copy_src)
{
sType = copy_src->sType;
stencilInitialLayout = copy_src->stencilInitialLayout;
stencilFinalLayout = copy_src->stencilFinalLayout;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures* in_struct) :
sType(in_struct->sType),
hostQueryReset(in_struct->hostQueryReset)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src)
{
sType = copy_src.sType;
hostQueryReset = copy_src.hostQueryReset;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceHostQueryResetFeatures& safe_VkPhysicalDeviceHostQueryResetFeatures::operator=(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
hostQueryReset = copy_src.hostQueryReset;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceHostQueryResetFeatures::~safe_VkPhysicalDeviceHostQueryResetFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceHostQueryResetFeatures::initialize(const VkPhysicalDeviceHostQueryResetFeatures* in_struct)
{
sType = in_struct->sType;
hostQueryReset = in_struct->hostQueryReset;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceHostQueryResetFeatures::initialize(const safe_VkPhysicalDeviceHostQueryResetFeatures* copy_src)
{
sType = copy_src->sType;
hostQueryReset = copy_src->hostQueryReset;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct) :
sType(in_struct->sType),
timelineSemaphore(in_struct->timelineSemaphore)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src)
{
sType = copy_src.sType;
timelineSemaphore = copy_src.timelineSemaphore;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTimelineSemaphoreFeatures& safe_VkPhysicalDeviceTimelineSemaphoreFeatures::operator=(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
timelineSemaphore = copy_src.timelineSemaphore;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTimelineSemaphoreFeatures::~safe_VkPhysicalDeviceTimelineSemaphoreFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceTimelineSemaphoreFeatures::initialize(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct)
{
sType = in_struct->sType;
timelineSemaphore = in_struct->timelineSemaphore;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceTimelineSemaphoreFeatures::initialize(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures* copy_src)
{
sType = copy_src->sType;
timelineSemaphore = copy_src->timelineSemaphore;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct) :
sType(in_struct->sType),
maxTimelineSemaphoreValueDifference(in_struct->maxTimelineSemaphoreValueDifference)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src)
{
sType = copy_src.sType;
maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTimelineSemaphoreProperties& safe_VkPhysicalDeviceTimelineSemaphoreProperties::operator=(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTimelineSemaphoreProperties::~safe_VkPhysicalDeviceTimelineSemaphoreProperties()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceTimelineSemaphoreProperties::initialize(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct)
{
sType = in_struct->sType;
maxTimelineSemaphoreValueDifference = in_struct->maxTimelineSemaphoreValueDifference;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceTimelineSemaphoreProperties::initialize(const safe_VkPhysicalDeviceTimelineSemaphoreProperties* copy_src)
{
sType = copy_src->sType;
maxTimelineSemaphoreValueDifference = copy_src->maxTimelineSemaphoreValueDifference;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* in_struct) :
sType(in_struct->sType),
semaphoreType(in_struct->semaphoreType),
initialValue(in_struct->initialValue)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo() :
sType(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO),
pNext(nullptr)
{}
safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo(const safe_VkSemaphoreTypeCreateInfo& copy_src)
{
sType = copy_src.sType;
semaphoreType = copy_src.semaphoreType;
initialValue = copy_src.initialValue;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSemaphoreTypeCreateInfo& safe_VkSemaphoreTypeCreateInfo::operator=(const safe_VkSemaphoreTypeCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphoreType = copy_src.semaphoreType;
initialValue = copy_src.initialValue;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSemaphoreTypeCreateInfo::~safe_VkSemaphoreTypeCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSemaphoreTypeCreateInfo::initialize(const VkSemaphoreTypeCreateInfo* in_struct)
{
sType = in_struct->sType;
semaphoreType = in_struct->semaphoreType;
initialValue = in_struct->initialValue;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSemaphoreTypeCreateInfo::initialize(const safe_VkSemaphoreTypeCreateInfo* copy_src)
{
sType = copy_src->sType;
semaphoreType = copy_src->semaphoreType;
initialValue = copy_src->initialValue;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* in_struct) :
sType(in_struct->sType),
waitSemaphoreValueCount(in_struct->waitSemaphoreValueCount),
pWaitSemaphoreValues(nullptr),
signalSemaphoreValueCount(in_struct->signalSemaphoreValueCount),
pSignalSemaphoreValues(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValueCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)in_struct->pWaitSemaphoreValues, sizeof(uint64_t)*in_struct->waitSemaphoreValueCount);
}
if (in_struct->pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValueCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)in_struct->pSignalSemaphoreValues, sizeof(uint64_t)*in_struct->signalSemaphoreValueCount);
}
}
safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo() :
sType(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO),
pNext(nullptr),
pWaitSemaphoreValues(nullptr),
pSignalSemaphoreValues(nullptr)
{}
safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo(const safe_VkTimelineSemaphoreSubmitInfo& copy_src)
{
sType = copy_src.sType;
waitSemaphoreValueCount = copy_src.waitSemaphoreValueCount;
pWaitSemaphoreValues = nullptr;
signalSemaphoreValueCount = copy_src.signalSemaphoreValueCount;
pSignalSemaphoreValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValueCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)copy_src.pWaitSemaphoreValues, sizeof(uint64_t)*copy_src.waitSemaphoreValueCount);
}
if (copy_src.pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValueCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)copy_src.pSignalSemaphoreValues, sizeof(uint64_t)*copy_src.signalSemaphoreValueCount);
}
}
safe_VkTimelineSemaphoreSubmitInfo& safe_VkTimelineSemaphoreSubmitInfo::operator=(const safe_VkTimelineSemaphoreSubmitInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pWaitSemaphoreValues)
delete[] pWaitSemaphoreValues;
if (pSignalSemaphoreValues)
delete[] pSignalSemaphoreValues;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
waitSemaphoreValueCount = copy_src.waitSemaphoreValueCount;
pWaitSemaphoreValues = nullptr;
signalSemaphoreValueCount = copy_src.signalSemaphoreValueCount;
pSignalSemaphoreValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValueCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)copy_src.pWaitSemaphoreValues, sizeof(uint64_t)*copy_src.waitSemaphoreValueCount);
}
if (copy_src.pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValueCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)copy_src.pSignalSemaphoreValues, sizeof(uint64_t)*copy_src.signalSemaphoreValueCount);
}
return *this;
}
safe_VkTimelineSemaphoreSubmitInfo::~safe_VkTimelineSemaphoreSubmitInfo()
{
if (pWaitSemaphoreValues)
delete[] pWaitSemaphoreValues;
if (pSignalSemaphoreValues)
delete[] pSignalSemaphoreValues;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkTimelineSemaphoreSubmitInfo::initialize(const VkTimelineSemaphoreSubmitInfo* in_struct)
{
sType = in_struct->sType;
waitSemaphoreValueCount = in_struct->waitSemaphoreValueCount;
pWaitSemaphoreValues = nullptr;
signalSemaphoreValueCount = in_struct->signalSemaphoreValueCount;
pSignalSemaphoreValues = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValueCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)in_struct->pWaitSemaphoreValues, sizeof(uint64_t)*in_struct->waitSemaphoreValueCount);
}
if (in_struct->pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValueCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)in_struct->pSignalSemaphoreValues, sizeof(uint64_t)*in_struct->signalSemaphoreValueCount);
}
}
void safe_VkTimelineSemaphoreSubmitInfo::initialize(const safe_VkTimelineSemaphoreSubmitInfo* copy_src)
{
sType = copy_src->sType;
waitSemaphoreValueCount = copy_src->waitSemaphoreValueCount;
pWaitSemaphoreValues = nullptr;
signalSemaphoreValueCount = copy_src->signalSemaphoreValueCount;
pSignalSemaphoreValues = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[copy_src->waitSemaphoreValueCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)copy_src->pWaitSemaphoreValues, sizeof(uint64_t)*copy_src->waitSemaphoreValueCount);
}
if (copy_src->pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[copy_src->signalSemaphoreValueCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)copy_src->pSignalSemaphoreValues, sizeof(uint64_t)*copy_src->signalSemaphoreValueCount);
}
}
safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
semaphoreCount(in_struct->semaphoreCount),
pSemaphores(nullptr),
pValues(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (semaphoreCount && in_struct->pSemaphores) {
pSemaphores = new VkSemaphore[semaphoreCount];
for (uint32_t i = 0; i < semaphoreCount; ++i) {
pSemaphores[i] = in_struct->pSemaphores[i];
}
}
if (in_struct->pValues) {
pValues = new uint64_t[in_struct->semaphoreCount];
memcpy ((void *)pValues, (void *)in_struct->pValues, sizeof(uint64_t)*in_struct->semaphoreCount);
}
}
safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo() :
sType(VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO),
pNext(nullptr),
pSemaphores(nullptr),
pValues(nullptr)
{}
safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo(const safe_VkSemaphoreWaitInfo& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
semaphoreCount = copy_src.semaphoreCount;
pSemaphores = nullptr;
pValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (semaphoreCount && copy_src.pSemaphores) {
pSemaphores = new VkSemaphore[semaphoreCount];
for (uint32_t i = 0; i < semaphoreCount; ++i) {
pSemaphores[i] = copy_src.pSemaphores[i];
}
}
if (copy_src.pValues) {
pValues = new uint64_t[copy_src.semaphoreCount];
memcpy ((void *)pValues, (void *)copy_src.pValues, sizeof(uint64_t)*copy_src.semaphoreCount);
}
}
safe_VkSemaphoreWaitInfo& safe_VkSemaphoreWaitInfo::operator=(const safe_VkSemaphoreWaitInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pSemaphores)
delete[] pSemaphores;
if (pValues)
delete[] pValues;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
semaphoreCount = copy_src.semaphoreCount;
pSemaphores = nullptr;
pValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (semaphoreCount && copy_src.pSemaphores) {
pSemaphores = new VkSemaphore[semaphoreCount];
for (uint32_t i = 0; i < semaphoreCount; ++i) {
pSemaphores[i] = copy_src.pSemaphores[i];
}
}
if (copy_src.pValues) {
pValues = new uint64_t[copy_src.semaphoreCount];
memcpy ((void *)pValues, (void *)copy_src.pValues, sizeof(uint64_t)*copy_src.semaphoreCount);
}
return *this;
}
safe_VkSemaphoreWaitInfo::~safe_VkSemaphoreWaitInfo()
{
if (pSemaphores)
delete[] pSemaphores;
if (pValues)
delete[] pValues;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSemaphoreWaitInfo::initialize(const VkSemaphoreWaitInfo* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
semaphoreCount = in_struct->semaphoreCount;
pSemaphores = nullptr;
pValues = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (semaphoreCount && in_struct->pSemaphores) {
pSemaphores = new VkSemaphore[semaphoreCount];
for (uint32_t i = 0; i < semaphoreCount; ++i) {
pSemaphores[i] = in_struct->pSemaphores[i];
}
}
if (in_struct->pValues) {
pValues = new uint64_t[in_struct->semaphoreCount];
memcpy ((void *)pValues, (void *)in_struct->pValues, sizeof(uint64_t)*in_struct->semaphoreCount);
}
}
void safe_VkSemaphoreWaitInfo::initialize(const safe_VkSemaphoreWaitInfo* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
semaphoreCount = copy_src->semaphoreCount;
pSemaphores = nullptr;
pValues = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (semaphoreCount && copy_src->pSemaphores) {
pSemaphores = new VkSemaphore[semaphoreCount];
for (uint32_t i = 0; i < semaphoreCount; ++i) {
pSemaphores[i] = copy_src->pSemaphores[i];
}
}
if (copy_src->pValues) {
pValues = new uint64_t[copy_src->semaphoreCount];
memcpy ((void *)pValues, (void *)copy_src->pValues, sizeof(uint64_t)*copy_src->semaphoreCount);
}
}
safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* in_struct) :
sType(in_struct->sType),
semaphore(in_struct->semaphore),
value(in_struct->value)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo() :
sType(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO),
pNext(nullptr)
{}
safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo(const safe_VkSemaphoreSignalInfo& copy_src)
{
sType = copy_src.sType;
semaphore = copy_src.semaphore;
value = copy_src.value;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSemaphoreSignalInfo& safe_VkSemaphoreSignalInfo::operator=(const safe_VkSemaphoreSignalInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphore = copy_src.semaphore;
value = copy_src.value;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSemaphoreSignalInfo::~safe_VkSemaphoreSignalInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSemaphoreSignalInfo::initialize(const VkSemaphoreSignalInfo* in_struct)
{
sType = in_struct->sType;
semaphore = in_struct->semaphore;
value = in_struct->value;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSemaphoreSignalInfo::initialize(const safe_VkSemaphoreSignalInfo* copy_src)
{
sType = copy_src->sType;
semaphore = copy_src->semaphore;
value = copy_src->value;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct) :
sType(in_struct->sType),
bufferDeviceAddress(in_struct->bufferDeviceAddress),
bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay),
bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES),
pNext(nullptr)
{}
safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src)
{
sType = copy_src.sType;
bufferDeviceAddress = copy_src.bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceBufferDeviceAddressFeatures& safe_VkPhysicalDeviceBufferDeviceAddressFeatures::operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
bufferDeviceAddress = copy_src.bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceBufferDeviceAddressFeatures::~safe_VkPhysicalDeviceBufferDeviceAddressFeatures()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceBufferDeviceAddressFeatures::initialize(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct)
{
sType = in_struct->sType;
bufferDeviceAddress = in_struct->bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceBufferDeviceAddressFeatures::initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures* copy_src)
{
sType = copy_src->sType;
bufferDeviceAddress = copy_src->bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* in_struct) :
sType(in_struct->sType),
buffer(in_struct->buffer)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo() :
sType(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO),
pNext(nullptr)
{}
safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo(const safe_VkBufferDeviceAddressInfo& copy_src)
{
sType = copy_src.sType;
buffer = copy_src.buffer;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferDeviceAddressInfo& safe_VkBufferDeviceAddressInfo::operator=(const safe_VkBufferDeviceAddressInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
buffer = copy_src.buffer;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferDeviceAddressInfo::~safe_VkBufferDeviceAddressInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferDeviceAddressInfo::initialize(const VkBufferDeviceAddressInfo* in_struct)
{
sType = in_struct->sType;
buffer = in_struct->buffer;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferDeviceAddressInfo::initialize(const safe_VkBufferDeviceAddressInfo* copy_src)
{
sType = copy_src->sType;
buffer = copy_src->buffer;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct) :
sType(in_struct->sType),
opaqueCaptureAddress(in_struct->opaqueCaptureAddress)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo() :
sType(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO),
pNext(nullptr)
{}
safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src)
{
sType = copy_src.sType;
opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferOpaqueCaptureAddressCreateInfo& safe_VkBufferOpaqueCaptureAddressCreateInfo::operator=(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferOpaqueCaptureAddressCreateInfo::~safe_VkBufferOpaqueCaptureAddressCreateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferOpaqueCaptureAddressCreateInfo::initialize(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct)
{
sType = in_struct->sType;
opaqueCaptureAddress = in_struct->opaqueCaptureAddress;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferOpaqueCaptureAddressCreateInfo::initialize(const safe_VkBufferOpaqueCaptureAddressCreateInfo* copy_src)
{
sType = copy_src->sType;
opaqueCaptureAddress = copy_src->opaqueCaptureAddress;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct) :
sType(in_struct->sType),
opaqueCaptureAddress(in_struct->opaqueCaptureAddress)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo() :
sType(VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO),
pNext(nullptr)
{}
safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src)
{
sType = copy_src.sType;
opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryOpaqueCaptureAddressAllocateInfo& safe_VkMemoryOpaqueCaptureAddressAllocateInfo::operator=(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryOpaqueCaptureAddressAllocateInfo::~safe_VkMemoryOpaqueCaptureAddressAllocateInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryOpaqueCaptureAddressAllocateInfo::initialize(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct)
{
sType = in_struct->sType;
opaqueCaptureAddress = in_struct->opaqueCaptureAddress;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryOpaqueCaptureAddressAllocateInfo::initialize(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo* copy_src)
{
sType = copy_src->sType;
opaqueCaptureAddress = copy_src->opaqueCaptureAddress;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct) :
sType(in_struct->sType),
memory(in_struct->memory)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo() :
sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO),
pNext(nullptr)
{}
safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src)
{
sType = copy_src.sType;
memory = copy_src.memory;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceMemoryOpaqueCaptureAddressInfo& safe_VkDeviceMemoryOpaqueCaptureAddressInfo::operator=(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memory = copy_src.memory;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceMemoryOpaqueCaptureAddressInfo::~safe_VkDeviceMemoryOpaqueCaptureAddressInfo()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceMemoryOpaqueCaptureAddressInfo::initialize(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct)
{
sType = in_struct->sType;
memory = in_struct->memory;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceMemoryOpaqueCaptureAddressInfo::initialize(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo* copy_src)
{
sType = copy_src->sType;
memory = copy_src->memory;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
surface(in_struct->surface),
minImageCount(in_struct->minImageCount),
imageFormat(in_struct->imageFormat),
imageColorSpace(in_struct->imageColorSpace),
imageExtent(in_struct->imageExtent),
imageArrayLayers(in_struct->imageArrayLayers),
imageUsage(in_struct->imageUsage),
imageSharingMode(in_struct->imageSharingMode),
queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
pQueueFamilyIndices(nullptr),
preTransform(in_struct->preTransform),
compositeAlpha(in_struct->compositeAlpha),
presentMode(in_struct->presentMode),
clipped(in_struct->clipped),
oldSwapchain(in_struct->oldSwapchain)
{
pNext = SafePnextCopy(in_struct->pNext);
if ((in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
}
}
safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR),
pNext(nullptr),
pQueueFamilyIndices(nullptr)
{}
safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
surface = copy_src.surface;
minImageCount = copy_src.minImageCount;
imageFormat = copy_src.imageFormat;
imageColorSpace = copy_src.imageColorSpace;
imageExtent = copy_src.imageExtent;
imageArrayLayers = copy_src.imageArrayLayers;
imageUsage = copy_src.imageUsage;
imageSharingMode = copy_src.imageSharingMode;
queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
preTransform = copy_src.preTransform;
compositeAlpha = copy_src.compositeAlpha;
presentMode = copy_src.presentMode;
clipped = copy_src.clipped;
oldSwapchain = copy_src.oldSwapchain;
pNext = SafePnextCopy(copy_src.pNext);
if ((copy_src.imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src.pQueueFamilyIndices, sizeof(uint32_t)*copy_src.queueFamilyIndexCount);
}
}
safe_VkSwapchainCreateInfoKHR& safe_VkSwapchainCreateInfoKHR::operator=(const safe_VkSwapchainCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pQueueFamilyIndices)
delete[] pQueueFamilyIndices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
surface = copy_src.surface;
minImageCount = copy_src.minImageCount;
imageFormat = copy_src.imageFormat;
imageColorSpace = copy_src.imageColorSpace;
imageExtent = copy_src.imageExtent;
imageArrayLayers = copy_src.imageArrayLayers;
imageUsage = copy_src.imageUsage;
imageSharingMode = copy_src.imageSharingMode;
queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
preTransform = copy_src.preTransform;
compositeAlpha = copy_src.compositeAlpha;
presentMode = copy_src.presentMode;
clipped = copy_src.clipped;
oldSwapchain = copy_src.oldSwapchain;
pNext = SafePnextCopy(copy_src.pNext);
if ((copy_src.imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src.pQueueFamilyIndices, sizeof(uint32_t)*copy_src.queueFamilyIndexCount);
}
return *this;
}
safe_VkSwapchainCreateInfoKHR::~safe_VkSwapchainCreateInfoKHR()
{
if (pQueueFamilyIndices)
delete[] pQueueFamilyIndices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSwapchainCreateInfoKHR::initialize(const VkSwapchainCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
surface = in_struct->surface;
minImageCount = in_struct->minImageCount;
imageFormat = in_struct->imageFormat;
imageColorSpace = in_struct->imageColorSpace;
imageExtent = in_struct->imageExtent;
imageArrayLayers = in_struct->imageArrayLayers;
imageUsage = in_struct->imageUsage;
imageSharingMode = in_struct->imageSharingMode;
queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
preTransform = in_struct->preTransform;
compositeAlpha = in_struct->compositeAlpha;
presentMode = in_struct->presentMode;
clipped = in_struct->clipped;
oldSwapchain = in_struct->oldSwapchain;
pNext = SafePnextCopy(in_struct->pNext);
if ((in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
}
}
void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
surface = copy_src->surface;
minImageCount = copy_src->minImageCount;
imageFormat = copy_src->imageFormat;
imageColorSpace = copy_src->imageColorSpace;
imageExtent = copy_src->imageExtent;
imageArrayLayers = copy_src->imageArrayLayers;
imageUsage = copy_src->imageUsage;
imageSharingMode = copy_src->imageSharingMode;
queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
preTransform = copy_src->preTransform;
compositeAlpha = copy_src->compositeAlpha;
presentMode = copy_src->presentMode;
clipped = copy_src->clipped;
oldSwapchain = copy_src->oldSwapchain;
pNext = SafePnextCopy(copy_src->pNext);
if ((copy_src->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src->pQueueFamilyIndices, sizeof(uint32_t)*copy_src->queueFamilyIndexCount);
}
}
safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct) :
sType(in_struct->sType),
waitSemaphoreCount(in_struct->waitSemaphoreCount),
pWaitSemaphores(nullptr),
swapchainCount(in_struct->swapchainCount),
pSwapchains(nullptr),
pImageIndices(nullptr),
pResults(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
}
}
if (swapchainCount && in_struct->pSwapchains) {
pSwapchains = new VkSwapchainKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pSwapchains[i] = in_struct->pSwapchains[i];
}
}
if (in_struct->pImageIndices) {
pImageIndices = new uint32_t[in_struct->swapchainCount];
memcpy ((void *)pImageIndices, (void *)in_struct->pImageIndices, sizeof(uint32_t)*in_struct->swapchainCount);
}
if (in_struct->pResults) {
pResults = new VkResult[in_struct->swapchainCount];
memcpy ((void *)pResults, (void *)in_struct->pResults, sizeof(VkResult)*in_struct->swapchainCount);
}
}
safe_VkPresentInfoKHR::safe_VkPresentInfoKHR() :
sType(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR),
pNext(nullptr),
pWaitSemaphores(nullptr),
pSwapchains(nullptr),
pImageIndices(nullptr),
pResults(nullptr)
{}
safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& copy_src)
{
sType = copy_src.sType;
waitSemaphoreCount = copy_src.waitSemaphoreCount;
pWaitSemaphores = nullptr;
swapchainCount = copy_src.swapchainCount;
pSwapchains = nullptr;
pImageIndices = nullptr;
pResults = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
}
}
if (swapchainCount && copy_src.pSwapchains) {
pSwapchains = new VkSwapchainKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pSwapchains[i] = copy_src.pSwapchains[i];
}
}
if (copy_src.pImageIndices) {
pImageIndices = new uint32_t[copy_src.swapchainCount];
memcpy ((void *)pImageIndices, (void *)copy_src.pImageIndices, sizeof(uint32_t)*copy_src.swapchainCount);
}
if (copy_src.pResults) {
pResults = new VkResult[copy_src.swapchainCount];
memcpy ((void *)pResults, (void *)copy_src.pResults, sizeof(VkResult)*copy_src.swapchainCount);
}
}
safe_VkPresentInfoKHR& safe_VkPresentInfoKHR::operator=(const safe_VkPresentInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pWaitSemaphores)
delete[] pWaitSemaphores;
if (pSwapchains)
delete[] pSwapchains;
if (pImageIndices)
delete[] pImageIndices;
if (pResults)
delete[] pResults;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
waitSemaphoreCount = copy_src.waitSemaphoreCount;
pWaitSemaphores = nullptr;
swapchainCount = copy_src.swapchainCount;
pSwapchains = nullptr;
pImageIndices = nullptr;
pResults = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
}
}
if (swapchainCount && copy_src.pSwapchains) {
pSwapchains = new VkSwapchainKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pSwapchains[i] = copy_src.pSwapchains[i];
}
}
if (copy_src.pImageIndices) {
pImageIndices = new uint32_t[copy_src.swapchainCount];
memcpy ((void *)pImageIndices, (void *)copy_src.pImageIndices, sizeof(uint32_t)*copy_src.swapchainCount);
}
if (copy_src.pResults) {
pResults = new VkResult[copy_src.swapchainCount];
memcpy ((void *)pResults, (void *)copy_src.pResults, sizeof(VkResult)*copy_src.swapchainCount);
}
return *this;
}
safe_VkPresentInfoKHR::~safe_VkPresentInfoKHR()
{
if (pWaitSemaphores)
delete[] pWaitSemaphores;
if (pSwapchains)
delete[] pSwapchains;
if (pImageIndices)
delete[] pImageIndices;
if (pResults)
delete[] pResults;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPresentInfoKHR::initialize(const VkPresentInfoKHR* in_struct)
{
sType = in_struct->sType;
waitSemaphoreCount = in_struct->waitSemaphoreCount;
pWaitSemaphores = nullptr;
swapchainCount = in_struct->swapchainCount;
pSwapchains = nullptr;
pImageIndices = nullptr;
pResults = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
}
}
if (swapchainCount && in_struct->pSwapchains) {
pSwapchains = new VkSwapchainKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pSwapchains[i] = in_struct->pSwapchains[i];
}
}
if (in_struct->pImageIndices) {
pImageIndices = new uint32_t[in_struct->swapchainCount];
memcpy ((void *)pImageIndices, (void *)in_struct->pImageIndices, sizeof(uint32_t)*in_struct->swapchainCount);
}
if (in_struct->pResults) {
pResults = new VkResult[in_struct->swapchainCount];
memcpy ((void *)pResults, (void *)in_struct->pResults, sizeof(VkResult)*in_struct->swapchainCount);
}
}
void safe_VkPresentInfoKHR::initialize(const safe_VkPresentInfoKHR* copy_src)
{
sType = copy_src->sType;
waitSemaphoreCount = copy_src->waitSemaphoreCount;
pWaitSemaphores = nullptr;
swapchainCount = copy_src->swapchainCount;
pSwapchains = nullptr;
pImageIndices = nullptr;
pResults = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (waitSemaphoreCount && copy_src->pWaitSemaphores) {
pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
pWaitSemaphores[i] = copy_src->pWaitSemaphores[i];
}
}
if (swapchainCount && copy_src->pSwapchains) {
pSwapchains = new VkSwapchainKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pSwapchains[i] = copy_src->pSwapchains[i];
}
}
if (copy_src->pImageIndices) {
pImageIndices = new uint32_t[copy_src->swapchainCount];
memcpy ((void *)pImageIndices, (void *)copy_src->pImageIndices, sizeof(uint32_t)*copy_src->swapchainCount);
}
if (copy_src->pResults) {
pResults = new VkResult[copy_src->swapchainCount];
memcpy ((void *)pResults, (void *)copy_src->pResults, sizeof(VkResult)*copy_src->swapchainCount);
}
}
safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct) :
sType(in_struct->sType),
swapchain(in_struct->swapchain)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
swapchain = copy_src.swapchain;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageSwapchainCreateInfoKHR& safe_VkImageSwapchainCreateInfoKHR::operator=(const safe_VkImageSwapchainCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
swapchain = copy_src.swapchain;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageSwapchainCreateInfoKHR::~safe_VkImageSwapchainCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageSwapchainCreateInfoKHR::initialize(const VkImageSwapchainCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
swapchain = in_struct->swapchain;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageSwapchainCreateInfoKHR::initialize(const safe_VkImageSwapchainCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
swapchain = copy_src->swapchain;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct) :
sType(in_struct->sType),
swapchain(in_struct->swapchain),
imageIndex(in_struct->imageIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR() :
sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR),
pNext(nullptr)
{}
safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src)
{
sType = copy_src.sType;
swapchain = copy_src.swapchain;
imageIndex = copy_src.imageIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBindImageMemorySwapchainInfoKHR& safe_VkBindImageMemorySwapchainInfoKHR::operator=(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
swapchain = copy_src.swapchain;
imageIndex = copy_src.imageIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBindImageMemorySwapchainInfoKHR::~safe_VkBindImageMemorySwapchainInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct)
{
sType = in_struct->sType;
swapchain = in_struct->swapchain;
imageIndex = in_struct->imageIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const safe_VkBindImageMemorySwapchainInfoKHR* copy_src)
{
sType = copy_src->sType;
swapchain = copy_src->swapchain;
imageIndex = copy_src->imageIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct) :
sType(in_struct->sType),
swapchain(in_struct->swapchain),
timeout(in_struct->timeout),
semaphore(in_struct->semaphore),
fence(in_struct->fence),
deviceMask(in_struct->deviceMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR() :
sType(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR),
pNext(nullptr)
{}
safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& copy_src)
{
sType = copy_src.sType;
swapchain = copy_src.swapchain;
timeout = copy_src.timeout;
semaphore = copy_src.semaphore;
fence = copy_src.fence;
deviceMask = copy_src.deviceMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAcquireNextImageInfoKHR& safe_VkAcquireNextImageInfoKHR::operator=(const safe_VkAcquireNextImageInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
swapchain = copy_src.swapchain;
timeout = copy_src.timeout;
semaphore = copy_src.semaphore;
fence = copy_src.fence;
deviceMask = copy_src.deviceMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAcquireNextImageInfoKHR::~safe_VkAcquireNextImageInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAcquireNextImageInfoKHR::initialize(const VkAcquireNextImageInfoKHR* in_struct)
{
sType = in_struct->sType;
swapchain = in_struct->swapchain;
timeout = in_struct->timeout;
semaphore = in_struct->semaphore;
fence = in_struct->fence;
deviceMask = in_struct->deviceMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAcquireNextImageInfoKHR::initialize(const safe_VkAcquireNextImageInfoKHR* copy_src)
{
sType = copy_src->sType;
swapchain = copy_src->swapchain;
timeout = copy_src->timeout;
semaphore = copy_src->semaphore;
fence = copy_src->fence;
deviceMask = copy_src->deviceMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct) :
sType(in_struct->sType),
modes(in_struct->modes)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
presentMask[i] = in_struct->presentMask[i];
}
}
safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR() :
sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR),
pNext(nullptr)
{}
safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src)
{
sType = copy_src.sType;
modes = copy_src.modes;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
presentMask[i] = copy_src.presentMask[i];
}
}
safe_VkDeviceGroupPresentCapabilitiesKHR& safe_VkDeviceGroupPresentCapabilitiesKHR::operator=(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
modes = copy_src.modes;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
presentMask[i] = copy_src.presentMask[i];
}
return *this;
}
safe_VkDeviceGroupPresentCapabilitiesKHR::~safe_VkDeviceGroupPresentCapabilitiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct)
{
sType = in_struct->sType;
modes = in_struct->modes;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
presentMask[i] = in_struct->presentMask[i];
}
}
void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* copy_src)
{
sType = copy_src->sType;
modes = copy_src->modes;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
presentMask[i] = copy_src->presentMask[i];
}
}
safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct) :
sType(in_struct->sType),
swapchainCount(in_struct->swapchainCount),
pDeviceMasks(nullptr),
mode(in_struct->mode)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceMasks) {
pDeviceMasks = new uint32_t[in_struct->swapchainCount];
memcpy ((void *)pDeviceMasks, (void *)in_struct->pDeviceMasks, sizeof(uint32_t)*in_struct->swapchainCount);
}
}
safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR() :
sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR),
pNext(nullptr),
pDeviceMasks(nullptr)
{}
safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& copy_src)
{
sType = copy_src.sType;
swapchainCount = copy_src.swapchainCount;
pDeviceMasks = nullptr;
mode = copy_src.mode;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceMasks) {
pDeviceMasks = new uint32_t[copy_src.swapchainCount];
memcpy ((void *)pDeviceMasks, (void *)copy_src.pDeviceMasks, sizeof(uint32_t)*copy_src.swapchainCount);
}
}
safe_VkDeviceGroupPresentInfoKHR& safe_VkDeviceGroupPresentInfoKHR::operator=(const safe_VkDeviceGroupPresentInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pDeviceMasks)
delete[] pDeviceMasks;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
swapchainCount = copy_src.swapchainCount;
pDeviceMasks = nullptr;
mode = copy_src.mode;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceMasks) {
pDeviceMasks = new uint32_t[copy_src.swapchainCount];
memcpy ((void *)pDeviceMasks, (void *)copy_src.pDeviceMasks, sizeof(uint32_t)*copy_src.swapchainCount);
}
return *this;
}
safe_VkDeviceGroupPresentInfoKHR::~safe_VkDeviceGroupPresentInfoKHR()
{
if (pDeviceMasks)
delete[] pDeviceMasks;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceGroupPresentInfoKHR::initialize(const VkDeviceGroupPresentInfoKHR* in_struct)
{
sType = in_struct->sType;
swapchainCount = in_struct->swapchainCount;
pDeviceMasks = nullptr;
mode = in_struct->mode;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceMasks) {
pDeviceMasks = new uint32_t[in_struct->swapchainCount];
memcpy ((void *)pDeviceMasks, (void *)in_struct->pDeviceMasks, sizeof(uint32_t)*in_struct->swapchainCount);
}
}
void safe_VkDeviceGroupPresentInfoKHR::initialize(const safe_VkDeviceGroupPresentInfoKHR* copy_src)
{
sType = copy_src->sType;
swapchainCount = copy_src->swapchainCount;
pDeviceMasks = nullptr;
mode = copy_src->mode;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDeviceMasks) {
pDeviceMasks = new uint32_t[copy_src->swapchainCount];
memcpy ((void *)pDeviceMasks, (void *)copy_src->pDeviceMasks, sizeof(uint32_t)*copy_src->swapchainCount);
}
}
safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct) :
sType(in_struct->sType),
modes(in_struct->modes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
modes = copy_src.modes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceGroupSwapchainCreateInfoKHR& safe_VkDeviceGroupSwapchainCreateInfoKHR::operator=(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
modes = copy_src.modes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceGroupSwapchainCreateInfoKHR::~safe_VkDeviceGroupSwapchainCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
modes = in_struct->modes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
modes = copy_src->modes;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
parameters(in_struct->parameters)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
parameters = copy_src.parameters;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayModeCreateInfoKHR& safe_VkDisplayModeCreateInfoKHR::operator=(const safe_VkDisplayModeCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
parameters = copy_src.parameters;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayModeCreateInfoKHR::~safe_VkDisplayModeCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayModeCreateInfoKHR::initialize(const VkDisplayModeCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
parameters = in_struct->parameters;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayModeCreateInfoKHR::initialize(const safe_VkDisplayModeCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
parameters = copy_src->parameters;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct) :
display(in_struct->display),
physicalDimensions(in_struct->physicalDimensions),
physicalResolution(in_struct->physicalResolution),
supportedTransforms(in_struct->supportedTransforms),
planeReorderPossible(in_struct->planeReorderPossible),
persistentContent(in_struct->persistentContent)
{
displayName = SafeStringCopy(in_struct->displayName);
}
safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR() :
displayName(nullptr)
{}
safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& copy_src)
{
display = copy_src.display;
physicalDimensions = copy_src.physicalDimensions;
physicalResolution = copy_src.physicalResolution;
supportedTransforms = copy_src.supportedTransforms;
planeReorderPossible = copy_src.planeReorderPossible;
persistentContent = copy_src.persistentContent;
displayName = SafeStringCopy(copy_src.displayName);
}
safe_VkDisplayPropertiesKHR& safe_VkDisplayPropertiesKHR::operator=(const safe_VkDisplayPropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (displayName) delete [] displayName;
display = copy_src.display;
physicalDimensions = copy_src.physicalDimensions;
physicalResolution = copy_src.physicalResolution;
supportedTransforms = copy_src.supportedTransforms;
planeReorderPossible = copy_src.planeReorderPossible;
persistentContent = copy_src.persistentContent;
displayName = SafeStringCopy(copy_src.displayName);
return *this;
}
safe_VkDisplayPropertiesKHR::~safe_VkDisplayPropertiesKHR()
{
if (displayName) delete [] displayName;
}
void safe_VkDisplayPropertiesKHR::initialize(const VkDisplayPropertiesKHR* in_struct)
{
display = in_struct->display;
physicalDimensions = in_struct->physicalDimensions;
physicalResolution = in_struct->physicalResolution;
supportedTransforms = in_struct->supportedTransforms;
planeReorderPossible = in_struct->planeReorderPossible;
persistentContent = in_struct->persistentContent;
displayName = SafeStringCopy(in_struct->displayName);
}
void safe_VkDisplayPropertiesKHR::initialize(const safe_VkDisplayPropertiesKHR* copy_src)
{
display = copy_src->display;
physicalDimensions = copy_src->physicalDimensions;
physicalResolution = copy_src->physicalResolution;
supportedTransforms = copy_src->supportedTransforms;
planeReorderPossible = copy_src->planeReorderPossible;
persistentContent = copy_src->persistentContent;
displayName = SafeStringCopy(copy_src->displayName);
}
safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
displayMode(in_struct->displayMode),
planeIndex(in_struct->planeIndex),
planeStackIndex(in_struct->planeStackIndex),
transform(in_struct->transform),
globalAlpha(in_struct->globalAlpha),
alphaMode(in_struct->alphaMode),
imageExtent(in_struct->imageExtent)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
displayMode = copy_src.displayMode;
planeIndex = copy_src.planeIndex;
planeStackIndex = copy_src.planeStackIndex;
transform = copy_src.transform;
globalAlpha = copy_src.globalAlpha;
alphaMode = copy_src.alphaMode;
imageExtent = copy_src.imageExtent;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplaySurfaceCreateInfoKHR& safe_VkDisplaySurfaceCreateInfoKHR::operator=(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
displayMode = copy_src.displayMode;
planeIndex = copy_src.planeIndex;
planeStackIndex = copy_src.planeStackIndex;
transform = copy_src.transform;
globalAlpha = copy_src.globalAlpha;
alphaMode = copy_src.alphaMode;
imageExtent = copy_src.imageExtent;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplaySurfaceCreateInfoKHR::~safe_VkDisplaySurfaceCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
displayMode = in_struct->displayMode;
planeIndex = in_struct->planeIndex;
planeStackIndex = in_struct->planeStackIndex;
transform = in_struct->transform;
globalAlpha = in_struct->globalAlpha;
alphaMode = in_struct->alphaMode;
imageExtent = in_struct->imageExtent;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const safe_VkDisplaySurfaceCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
displayMode = copy_src->displayMode;
planeIndex = copy_src->planeIndex;
planeStackIndex = copy_src->planeStackIndex;
transform = copy_src->transform;
globalAlpha = copy_src->globalAlpha;
alphaMode = copy_src->alphaMode;
imageExtent = copy_src->imageExtent;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct) :
sType(in_struct->sType),
srcRect(in_struct->srcRect),
dstRect(in_struct->dstRect),
persistent(in_struct->persistent)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR() :
sType(VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR),
pNext(nullptr)
{}
safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& copy_src)
{
sType = copy_src.sType;
srcRect = copy_src.srcRect;
dstRect = copy_src.dstRect;
persistent = copy_src.persistent;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayPresentInfoKHR& safe_VkDisplayPresentInfoKHR::operator=(const safe_VkDisplayPresentInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcRect = copy_src.srcRect;
dstRect = copy_src.dstRect;
persistent = copy_src.persistent;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayPresentInfoKHR::~safe_VkDisplayPresentInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayPresentInfoKHR::initialize(const VkDisplayPresentInfoKHR* in_struct)
{
sType = in_struct->sType;
srcRect = in_struct->srcRect;
dstRect = in_struct->dstRect;
persistent = in_struct->persistent;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayPresentInfoKHR::initialize(const safe_VkDisplayPresentInfoKHR* copy_src)
{
sType = copy_src->sType;
srcRect = copy_src->srcRect;
dstRect = copy_src->dstRect;
persistent = copy_src->persistent;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoQueueFamilyProperties2KHR::safe_VkVideoQueueFamilyProperties2KHR(const VkVideoQueueFamilyProperties2KHR* in_struct) :
sType(in_struct->sType),
videoCodecOperations(in_struct->videoCodecOperations)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoQueueFamilyProperties2KHR::safe_VkVideoQueueFamilyProperties2KHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR),
pNext(nullptr)
{}
safe_VkVideoQueueFamilyProperties2KHR::safe_VkVideoQueueFamilyProperties2KHR(const safe_VkVideoQueueFamilyProperties2KHR& copy_src)
{
sType = copy_src.sType;
videoCodecOperations = copy_src.videoCodecOperations;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoQueueFamilyProperties2KHR& safe_VkVideoQueueFamilyProperties2KHR::operator=(const safe_VkVideoQueueFamilyProperties2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
videoCodecOperations = copy_src.videoCodecOperations;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoQueueFamilyProperties2KHR::~safe_VkVideoQueueFamilyProperties2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoQueueFamilyProperties2KHR::initialize(const VkVideoQueueFamilyProperties2KHR* in_struct)
{
sType = in_struct->sType;
videoCodecOperations = in_struct->videoCodecOperations;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoQueueFamilyProperties2KHR::initialize(const safe_VkVideoQueueFamilyProperties2KHR* copy_src)
{
sType = copy_src->sType;
videoCodecOperations = copy_src->videoCodecOperations;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoProfileKHR::safe_VkVideoProfileKHR(const VkVideoProfileKHR* in_struct) :
sType(in_struct->sType),
videoCodecOperation(in_struct->videoCodecOperation),
chromaSubsampling(in_struct->chromaSubsampling),
lumaBitDepth(in_struct->lumaBitDepth),
chromaBitDepth(in_struct->chromaBitDepth)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoProfileKHR::safe_VkVideoProfileKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR),
pNext(nullptr)
{}
safe_VkVideoProfileKHR::safe_VkVideoProfileKHR(const safe_VkVideoProfileKHR& copy_src)
{
sType = copy_src.sType;
videoCodecOperation = copy_src.videoCodecOperation;
chromaSubsampling = copy_src.chromaSubsampling;
lumaBitDepth = copy_src.lumaBitDepth;
chromaBitDepth = copy_src.chromaBitDepth;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoProfileKHR& safe_VkVideoProfileKHR::operator=(const safe_VkVideoProfileKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
videoCodecOperation = copy_src.videoCodecOperation;
chromaSubsampling = copy_src.chromaSubsampling;
lumaBitDepth = copy_src.lumaBitDepth;
chromaBitDepth = copy_src.chromaBitDepth;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoProfileKHR::~safe_VkVideoProfileKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoProfileKHR::initialize(const VkVideoProfileKHR* in_struct)
{
sType = in_struct->sType;
videoCodecOperation = in_struct->videoCodecOperation;
chromaSubsampling = in_struct->chromaSubsampling;
lumaBitDepth = in_struct->lumaBitDepth;
chromaBitDepth = in_struct->chromaBitDepth;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoProfileKHR::initialize(const safe_VkVideoProfileKHR* copy_src)
{
sType = copy_src->sType;
videoCodecOperation = copy_src->videoCodecOperation;
chromaSubsampling = copy_src->chromaSubsampling;
lumaBitDepth = copy_src->lumaBitDepth;
chromaBitDepth = copy_src->chromaBitDepth;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoProfilesKHR::safe_VkVideoProfilesKHR(const VkVideoProfilesKHR* in_struct) :
sType(in_struct->sType),
profileCount(in_struct->profileCount),
pProfiles(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pProfiles)
pProfiles = new safe_VkVideoProfileKHR(in_struct->pProfiles);
}
safe_VkVideoProfilesKHR::safe_VkVideoProfilesKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR),
pNext(nullptr),
pProfiles(nullptr)
{}
safe_VkVideoProfilesKHR::safe_VkVideoProfilesKHR(const safe_VkVideoProfilesKHR& copy_src)
{
sType = copy_src.sType;
profileCount = copy_src.profileCount;
pProfiles = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pProfiles)
pProfiles = new safe_VkVideoProfileKHR(*copy_src.pProfiles);
}
safe_VkVideoProfilesKHR& safe_VkVideoProfilesKHR::operator=(const safe_VkVideoProfilesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pProfiles)
delete pProfiles;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
profileCount = copy_src.profileCount;
pProfiles = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pProfiles)
pProfiles = new safe_VkVideoProfileKHR(*copy_src.pProfiles);
return *this;
}
safe_VkVideoProfilesKHR::~safe_VkVideoProfilesKHR()
{
if (pProfiles)
delete pProfiles;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoProfilesKHR::initialize(const VkVideoProfilesKHR* in_struct)
{
sType = in_struct->sType;
profileCount = in_struct->profileCount;
pProfiles = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pProfiles)
pProfiles = new safe_VkVideoProfileKHR(in_struct->pProfiles);
}
void safe_VkVideoProfilesKHR::initialize(const safe_VkVideoProfilesKHR* copy_src)
{
sType = copy_src->sType;
profileCount = copy_src->profileCount;
pProfiles = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pProfiles)
pProfiles = new safe_VkVideoProfileKHR(*copy_src->pProfiles);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* in_struct) :
sType(in_struct->sType),
capabilityFlags(in_struct->capabilityFlags),
minBitstreamBufferOffsetAlignment(in_struct->minBitstreamBufferOffsetAlignment),
minBitstreamBufferSizeAlignment(in_struct->minBitstreamBufferSizeAlignment),
videoPictureExtentGranularity(in_struct->videoPictureExtentGranularity),
minExtent(in_struct->minExtent),
maxExtent(in_struct->maxExtent),
maxReferencePicturesSlotsCount(in_struct->maxReferencePicturesSlotsCount),
maxReferencePicturesActiveCount(in_struct->maxReferencePicturesActiveCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR),
pNext(nullptr)
{}
safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR(const safe_VkVideoCapabilitiesKHR& copy_src)
{
sType = copy_src.sType;
capabilityFlags = copy_src.capabilityFlags;
minBitstreamBufferOffsetAlignment = copy_src.minBitstreamBufferOffsetAlignment;
minBitstreamBufferSizeAlignment = copy_src.minBitstreamBufferSizeAlignment;
videoPictureExtentGranularity = copy_src.videoPictureExtentGranularity;
minExtent = copy_src.minExtent;
maxExtent = copy_src.maxExtent;
maxReferencePicturesSlotsCount = copy_src.maxReferencePicturesSlotsCount;
maxReferencePicturesActiveCount = copy_src.maxReferencePicturesActiveCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoCapabilitiesKHR& safe_VkVideoCapabilitiesKHR::operator=(const safe_VkVideoCapabilitiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
capabilityFlags = copy_src.capabilityFlags;
minBitstreamBufferOffsetAlignment = copy_src.minBitstreamBufferOffsetAlignment;
minBitstreamBufferSizeAlignment = copy_src.minBitstreamBufferSizeAlignment;
videoPictureExtentGranularity = copy_src.videoPictureExtentGranularity;
minExtent = copy_src.minExtent;
maxExtent = copy_src.maxExtent;
maxReferencePicturesSlotsCount = copy_src.maxReferencePicturesSlotsCount;
maxReferencePicturesActiveCount = copy_src.maxReferencePicturesActiveCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoCapabilitiesKHR::~safe_VkVideoCapabilitiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoCapabilitiesKHR::initialize(const VkVideoCapabilitiesKHR* in_struct)
{
sType = in_struct->sType;
capabilityFlags = in_struct->capabilityFlags;
minBitstreamBufferOffsetAlignment = in_struct->minBitstreamBufferOffsetAlignment;
minBitstreamBufferSizeAlignment = in_struct->minBitstreamBufferSizeAlignment;
videoPictureExtentGranularity = in_struct->videoPictureExtentGranularity;
minExtent = in_struct->minExtent;
maxExtent = in_struct->maxExtent;
maxReferencePicturesSlotsCount = in_struct->maxReferencePicturesSlotsCount;
maxReferencePicturesActiveCount = in_struct->maxReferencePicturesActiveCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoCapabilitiesKHR::initialize(const safe_VkVideoCapabilitiesKHR* copy_src)
{
sType = copy_src->sType;
capabilityFlags = copy_src->capabilityFlags;
minBitstreamBufferOffsetAlignment = copy_src->minBitstreamBufferOffsetAlignment;
minBitstreamBufferSizeAlignment = copy_src->minBitstreamBufferSizeAlignment;
videoPictureExtentGranularity = copy_src->videoPictureExtentGranularity;
minExtent = copy_src->minExtent;
maxExtent = copy_src->maxExtent;
maxReferencePicturesSlotsCount = copy_src->maxReferencePicturesSlotsCount;
maxReferencePicturesActiveCount = copy_src->maxReferencePicturesActiveCount;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct) :
sType(in_struct->sType),
imageUsage(in_struct->imageUsage),
pVideoProfiles(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVideoProfiles)
pVideoProfiles = new safe_VkVideoProfilesKHR(in_struct->pVideoProfiles);
}
safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR),
pNext(nullptr),
pVideoProfiles(nullptr)
{}
safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR(const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src)
{
sType = copy_src.sType;
imageUsage = copy_src.imageUsage;
pVideoProfiles = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVideoProfiles)
pVideoProfiles = new safe_VkVideoProfilesKHR(*copy_src.pVideoProfiles);
}
safe_VkPhysicalDeviceVideoFormatInfoKHR& safe_VkPhysicalDeviceVideoFormatInfoKHR::operator=(const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pVideoProfiles)
delete pVideoProfiles;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
imageUsage = copy_src.imageUsage;
pVideoProfiles = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVideoProfiles)
pVideoProfiles = new safe_VkVideoProfilesKHR(*copy_src.pVideoProfiles);
return *this;
}
safe_VkPhysicalDeviceVideoFormatInfoKHR::~safe_VkPhysicalDeviceVideoFormatInfoKHR()
{
if (pVideoProfiles)
delete pVideoProfiles;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVideoFormatInfoKHR::initialize(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct)
{
sType = in_struct->sType;
imageUsage = in_struct->imageUsage;
pVideoProfiles = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVideoProfiles)
pVideoProfiles = new safe_VkVideoProfilesKHR(in_struct->pVideoProfiles);
}
void safe_VkPhysicalDeviceVideoFormatInfoKHR::initialize(const safe_VkPhysicalDeviceVideoFormatInfoKHR* copy_src)
{
sType = copy_src->sType;
imageUsage = copy_src->imageUsage;
pVideoProfiles = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pVideoProfiles)
pVideoProfiles = new safe_VkVideoProfilesKHR(*copy_src->pVideoProfiles);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* in_struct) :
sType(in_struct->sType),
format(in_struct->format)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR(const safe_VkVideoFormatPropertiesKHR& copy_src)
{
sType = copy_src.sType;
format = copy_src.format;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoFormatPropertiesKHR& safe_VkVideoFormatPropertiesKHR::operator=(const safe_VkVideoFormatPropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
format = copy_src.format;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoFormatPropertiesKHR::~safe_VkVideoFormatPropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoFormatPropertiesKHR::initialize(const VkVideoFormatPropertiesKHR* in_struct)
{
sType = in_struct->sType;
format = in_struct->format;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoFormatPropertiesKHR::initialize(const safe_VkVideoFormatPropertiesKHR* copy_src)
{
sType = copy_src->sType;
format = copy_src->format;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoPictureResourceKHR::safe_VkVideoPictureResourceKHR(const VkVideoPictureResourceKHR* in_struct) :
sType(in_struct->sType),
codedOffset(in_struct->codedOffset),
codedExtent(in_struct->codedExtent),
baseArrayLayer(in_struct->baseArrayLayer),
imageViewBinding(in_struct->imageViewBinding)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoPictureResourceKHR::safe_VkVideoPictureResourceKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR),
pNext(nullptr)
{}
safe_VkVideoPictureResourceKHR::safe_VkVideoPictureResourceKHR(const safe_VkVideoPictureResourceKHR& copy_src)
{
sType = copy_src.sType;
codedOffset = copy_src.codedOffset;
codedExtent = copy_src.codedExtent;
baseArrayLayer = copy_src.baseArrayLayer;
imageViewBinding = copy_src.imageViewBinding;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoPictureResourceKHR& safe_VkVideoPictureResourceKHR::operator=(const safe_VkVideoPictureResourceKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
codedOffset = copy_src.codedOffset;
codedExtent = copy_src.codedExtent;
baseArrayLayer = copy_src.baseArrayLayer;
imageViewBinding = copy_src.imageViewBinding;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoPictureResourceKHR::~safe_VkVideoPictureResourceKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoPictureResourceKHR::initialize(const VkVideoPictureResourceKHR* in_struct)
{
sType = in_struct->sType;
codedOffset = in_struct->codedOffset;
codedExtent = in_struct->codedExtent;
baseArrayLayer = in_struct->baseArrayLayer;
imageViewBinding = in_struct->imageViewBinding;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoPictureResourceKHR::initialize(const safe_VkVideoPictureResourceKHR* copy_src)
{
sType = copy_src->sType;
codedOffset = copy_src->codedOffset;
codedExtent = copy_src->codedExtent;
baseArrayLayer = copy_src->baseArrayLayer;
imageViewBinding = copy_src->imageViewBinding;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoReferenceSlotKHR::safe_VkVideoReferenceSlotKHR(const VkVideoReferenceSlotKHR* in_struct) :
sType(in_struct->sType),
slotIndex(in_struct->slotIndex),
pPictureResource(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPictureResource)
pPictureResource = new safe_VkVideoPictureResourceKHR(in_struct->pPictureResource);
}
safe_VkVideoReferenceSlotKHR::safe_VkVideoReferenceSlotKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR),
pNext(nullptr),
pPictureResource(nullptr)
{}
safe_VkVideoReferenceSlotKHR::safe_VkVideoReferenceSlotKHR(const safe_VkVideoReferenceSlotKHR& copy_src)
{
sType = copy_src.sType;
slotIndex = copy_src.slotIndex;
pPictureResource = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPictureResource)
pPictureResource = new safe_VkVideoPictureResourceKHR(*copy_src.pPictureResource);
}
safe_VkVideoReferenceSlotKHR& safe_VkVideoReferenceSlotKHR::operator=(const safe_VkVideoReferenceSlotKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pPictureResource)
delete pPictureResource;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
slotIndex = copy_src.slotIndex;
pPictureResource = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPictureResource)
pPictureResource = new safe_VkVideoPictureResourceKHR(*copy_src.pPictureResource);
return *this;
}
safe_VkVideoReferenceSlotKHR::~safe_VkVideoReferenceSlotKHR()
{
if (pPictureResource)
delete pPictureResource;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoReferenceSlotKHR::initialize(const VkVideoReferenceSlotKHR* in_struct)
{
sType = in_struct->sType;
slotIndex = in_struct->slotIndex;
pPictureResource = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPictureResource)
pPictureResource = new safe_VkVideoPictureResourceKHR(in_struct->pPictureResource);
}
void safe_VkVideoReferenceSlotKHR::initialize(const safe_VkVideoReferenceSlotKHR* copy_src)
{
sType = copy_src->sType;
slotIndex = copy_src->slotIndex;
pPictureResource = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pPictureResource)
pPictureResource = new safe_VkVideoPictureResourceKHR(*copy_src->pPictureResource);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoGetMemoryPropertiesKHR::safe_VkVideoGetMemoryPropertiesKHR(const VkVideoGetMemoryPropertiesKHR* in_struct) :
sType(in_struct->sType),
memoryBindIndex(in_struct->memoryBindIndex),
pMemoryRequirements(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pMemoryRequirements)
pMemoryRequirements = new safe_VkMemoryRequirements2(in_struct->pMemoryRequirements);
}
safe_VkVideoGetMemoryPropertiesKHR::safe_VkVideoGetMemoryPropertiesKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR),
pNext(nullptr),
pMemoryRequirements(nullptr)
{}
safe_VkVideoGetMemoryPropertiesKHR::safe_VkVideoGetMemoryPropertiesKHR(const safe_VkVideoGetMemoryPropertiesKHR& copy_src)
{
sType = copy_src.sType;
memoryBindIndex = copy_src.memoryBindIndex;
pMemoryRequirements = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pMemoryRequirements)
pMemoryRequirements = new safe_VkMemoryRequirements2(*copy_src.pMemoryRequirements);
}
safe_VkVideoGetMemoryPropertiesKHR& safe_VkVideoGetMemoryPropertiesKHR::operator=(const safe_VkVideoGetMemoryPropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pMemoryRequirements)
delete pMemoryRequirements;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryBindIndex = copy_src.memoryBindIndex;
pMemoryRequirements = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pMemoryRequirements)
pMemoryRequirements = new safe_VkMemoryRequirements2(*copy_src.pMemoryRequirements);
return *this;
}
safe_VkVideoGetMemoryPropertiesKHR::~safe_VkVideoGetMemoryPropertiesKHR()
{
if (pMemoryRequirements)
delete pMemoryRequirements;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoGetMemoryPropertiesKHR::initialize(const VkVideoGetMemoryPropertiesKHR* in_struct)
{
sType = in_struct->sType;
memoryBindIndex = in_struct->memoryBindIndex;
pMemoryRequirements = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pMemoryRequirements)
pMemoryRequirements = new safe_VkMemoryRequirements2(in_struct->pMemoryRequirements);
}
void safe_VkVideoGetMemoryPropertiesKHR::initialize(const safe_VkVideoGetMemoryPropertiesKHR* copy_src)
{
sType = copy_src->sType;
memoryBindIndex = copy_src->memoryBindIndex;
pMemoryRequirements = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pMemoryRequirements)
pMemoryRequirements = new safe_VkMemoryRequirements2(*copy_src->pMemoryRequirements);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoBindMemoryKHR::safe_VkVideoBindMemoryKHR(const VkVideoBindMemoryKHR* in_struct) :
sType(in_struct->sType),
memoryBindIndex(in_struct->memoryBindIndex),
memory(in_struct->memory),
memoryOffset(in_struct->memoryOffset),
memorySize(in_struct->memorySize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoBindMemoryKHR::safe_VkVideoBindMemoryKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR),
pNext(nullptr)
{}
safe_VkVideoBindMemoryKHR::safe_VkVideoBindMemoryKHR(const safe_VkVideoBindMemoryKHR& copy_src)
{
sType = copy_src.sType;
memoryBindIndex = copy_src.memoryBindIndex;
memory = copy_src.memory;
memoryOffset = copy_src.memoryOffset;
memorySize = copy_src.memorySize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoBindMemoryKHR& safe_VkVideoBindMemoryKHR::operator=(const safe_VkVideoBindMemoryKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryBindIndex = copy_src.memoryBindIndex;
memory = copy_src.memory;
memoryOffset = copy_src.memoryOffset;
memorySize = copy_src.memorySize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoBindMemoryKHR::~safe_VkVideoBindMemoryKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoBindMemoryKHR::initialize(const VkVideoBindMemoryKHR* in_struct)
{
sType = in_struct->sType;
memoryBindIndex = in_struct->memoryBindIndex;
memory = in_struct->memory;
memoryOffset = in_struct->memoryOffset;
memorySize = in_struct->memorySize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoBindMemoryKHR::initialize(const safe_VkVideoBindMemoryKHR* copy_src)
{
sType = copy_src->sType;
memoryBindIndex = copy_src->memoryBindIndex;
memory = copy_src->memory;
memoryOffset = copy_src->memoryOffset;
memorySize = copy_src->memorySize;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* in_struct) :
sType(in_struct->sType),
queueFamilyIndex(in_struct->queueFamilyIndex),
flags(in_struct->flags),
pVideoProfile(nullptr),
pictureFormat(in_struct->pictureFormat),
maxCodedExtent(in_struct->maxCodedExtent),
referencePicturesFormat(in_struct->referencePicturesFormat),
maxReferencePicturesSlotsCount(in_struct->maxReferencePicturesSlotsCount),
maxReferencePicturesActiveCount(in_struct->maxReferencePicturesActiveCount)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVideoProfile)
pVideoProfile = new safe_VkVideoProfileKHR(in_struct->pVideoProfile);
}
safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR),
pNext(nullptr),
pVideoProfile(nullptr)
{}
safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR(const safe_VkVideoSessionCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
queueFamilyIndex = copy_src.queueFamilyIndex;
flags = copy_src.flags;
pVideoProfile = nullptr;
pictureFormat = copy_src.pictureFormat;
maxCodedExtent = copy_src.maxCodedExtent;
referencePicturesFormat = copy_src.referencePicturesFormat;
maxReferencePicturesSlotsCount = copy_src.maxReferencePicturesSlotsCount;
maxReferencePicturesActiveCount = copy_src.maxReferencePicturesActiveCount;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVideoProfile)
pVideoProfile = new safe_VkVideoProfileKHR(*copy_src.pVideoProfile);
}
safe_VkVideoSessionCreateInfoKHR& safe_VkVideoSessionCreateInfoKHR::operator=(const safe_VkVideoSessionCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pVideoProfile)
delete pVideoProfile;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
queueFamilyIndex = copy_src.queueFamilyIndex;
flags = copy_src.flags;
pVideoProfile = nullptr;
pictureFormat = copy_src.pictureFormat;
maxCodedExtent = copy_src.maxCodedExtent;
referencePicturesFormat = copy_src.referencePicturesFormat;
maxReferencePicturesSlotsCount = copy_src.maxReferencePicturesSlotsCount;
maxReferencePicturesActiveCount = copy_src.maxReferencePicturesActiveCount;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVideoProfile)
pVideoProfile = new safe_VkVideoProfileKHR(*copy_src.pVideoProfile);
return *this;
}
safe_VkVideoSessionCreateInfoKHR::~safe_VkVideoSessionCreateInfoKHR()
{
if (pVideoProfile)
delete pVideoProfile;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoSessionCreateInfoKHR::initialize(const VkVideoSessionCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
queueFamilyIndex = in_struct->queueFamilyIndex;
flags = in_struct->flags;
pVideoProfile = nullptr;
pictureFormat = in_struct->pictureFormat;
maxCodedExtent = in_struct->maxCodedExtent;
referencePicturesFormat = in_struct->referencePicturesFormat;
maxReferencePicturesSlotsCount = in_struct->maxReferencePicturesSlotsCount;
maxReferencePicturesActiveCount = in_struct->maxReferencePicturesActiveCount;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVideoProfile)
pVideoProfile = new safe_VkVideoProfileKHR(in_struct->pVideoProfile);
}
void safe_VkVideoSessionCreateInfoKHR::initialize(const safe_VkVideoSessionCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
queueFamilyIndex = copy_src->queueFamilyIndex;
flags = copy_src->flags;
pVideoProfile = nullptr;
pictureFormat = copy_src->pictureFormat;
maxCodedExtent = copy_src->maxCodedExtent;
referencePicturesFormat = copy_src->referencePicturesFormat;
maxReferencePicturesSlotsCount = copy_src->maxReferencePicturesSlotsCount;
maxReferencePicturesActiveCount = copy_src->maxReferencePicturesActiveCount;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pVideoProfile)
pVideoProfile = new safe_VkVideoProfileKHR(*copy_src->pVideoProfile);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR(const VkVideoSessionParametersCreateInfoKHR* in_struct) :
sType(in_struct->sType),
videoSessionParametersTemplate(in_struct->videoSessionParametersTemplate),
videoSession(in_struct->videoSession)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR(const safe_VkVideoSessionParametersCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
videoSessionParametersTemplate = copy_src.videoSessionParametersTemplate;
videoSession = copy_src.videoSession;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoSessionParametersCreateInfoKHR& safe_VkVideoSessionParametersCreateInfoKHR::operator=(const safe_VkVideoSessionParametersCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
videoSessionParametersTemplate = copy_src.videoSessionParametersTemplate;
videoSession = copy_src.videoSession;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoSessionParametersCreateInfoKHR::~safe_VkVideoSessionParametersCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoSessionParametersCreateInfoKHR::initialize(const VkVideoSessionParametersCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
videoSessionParametersTemplate = in_struct->videoSessionParametersTemplate;
videoSession = in_struct->videoSession;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoSessionParametersCreateInfoKHR::initialize(const safe_VkVideoSessionParametersCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
videoSessionParametersTemplate = copy_src->videoSessionParametersTemplate;
videoSession = copy_src->videoSession;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR(const VkVideoSessionParametersUpdateInfoKHR* in_struct) :
sType(in_struct->sType),
updateSequenceCount(in_struct->updateSequenceCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR(const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src)
{
sType = copy_src.sType;
updateSequenceCount = copy_src.updateSequenceCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoSessionParametersUpdateInfoKHR& safe_VkVideoSessionParametersUpdateInfoKHR::operator=(const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
updateSequenceCount = copy_src.updateSequenceCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoSessionParametersUpdateInfoKHR::~safe_VkVideoSessionParametersUpdateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoSessionParametersUpdateInfoKHR::initialize(const VkVideoSessionParametersUpdateInfoKHR* in_struct)
{
sType = in_struct->sType;
updateSequenceCount = in_struct->updateSequenceCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoSessionParametersUpdateInfoKHR::initialize(const safe_VkVideoSessionParametersUpdateInfoKHR* copy_src)
{
sType = copy_src->sType;
updateSequenceCount = copy_src->updateSequenceCount;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
codecQualityPreset(in_struct->codecQualityPreset),
videoSession(in_struct->videoSession),
videoSessionParameters(in_struct->videoSessionParameters),
referenceSlotCount(in_struct->referenceSlotCount),
pReferenceSlots(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (referenceSlotCount && in_struct->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
}
}
}
safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR),
pNext(nullptr),
pReferenceSlots(nullptr)
{}
safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR(const safe_VkVideoBeginCodingInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
codecQualityPreset = copy_src.codecQualityPreset;
videoSession = copy_src.videoSession;
videoSessionParameters = copy_src.videoSessionParameters;
referenceSlotCount = copy_src.referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (referenceSlotCount && copy_src.pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
}
}
}
safe_VkVideoBeginCodingInfoKHR& safe_VkVideoBeginCodingInfoKHR::operator=(const safe_VkVideoBeginCodingInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pReferenceSlots)
delete[] pReferenceSlots;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
codecQualityPreset = copy_src.codecQualityPreset;
videoSession = copy_src.videoSession;
videoSessionParameters = copy_src.videoSessionParameters;
referenceSlotCount = copy_src.referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (referenceSlotCount && copy_src.pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
}
}
return *this;
}
safe_VkVideoBeginCodingInfoKHR::~safe_VkVideoBeginCodingInfoKHR()
{
if (pReferenceSlots)
delete[] pReferenceSlots;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoBeginCodingInfoKHR::initialize(const VkVideoBeginCodingInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
codecQualityPreset = in_struct->codecQualityPreset;
videoSession = in_struct->videoSession;
videoSessionParameters = in_struct->videoSessionParameters;
referenceSlotCount = in_struct->referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (referenceSlotCount && in_struct->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
}
}
}
void safe_VkVideoBeginCodingInfoKHR::initialize(const safe_VkVideoBeginCodingInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
codecQualityPreset = copy_src->codecQualityPreset;
videoSession = copy_src->videoSession;
videoSessionParameters = copy_src->videoSessionParameters;
referenceSlotCount = copy_src->referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (referenceSlotCount && copy_src->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
}
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR),
pNext(nullptr)
{}
safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR(const safe_VkVideoEndCodingInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoEndCodingInfoKHR& safe_VkVideoEndCodingInfoKHR::operator=(const safe_VkVideoEndCodingInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoEndCodingInfoKHR::~safe_VkVideoEndCodingInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEndCodingInfoKHR::initialize(const VkVideoEndCodingInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoEndCodingInfoKHR::initialize(const safe_VkVideoEndCodingInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR),
pNext(nullptr)
{}
safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR(const safe_VkVideoCodingControlInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoCodingControlInfoKHR& safe_VkVideoCodingControlInfoKHR::operator=(const safe_VkVideoCodingControlInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoCodingControlInfoKHR::~safe_VkVideoCodingControlInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoCodingControlInfoKHR::initialize(const VkVideoCodingControlInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoCodingControlInfoKHR::initialize(const safe_VkVideoCodingControlInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
codedOffset(in_struct->codedOffset),
codedExtent(in_struct->codedExtent),
srcBuffer(in_struct->srcBuffer),
srcBufferOffset(in_struct->srcBufferOffset),
srcBufferRange(in_struct->srcBufferRange),
dstPictureResource(&in_struct->dstPictureResource),
pSetupReferenceSlot(nullptr),
referenceSlotCount(in_struct->referenceSlotCount),
pReferenceSlots(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(in_struct->pSetupReferenceSlot);
if (referenceSlotCount && in_struct->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
}
}
}
safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR),
pNext(nullptr),
pSetupReferenceSlot(nullptr),
pReferenceSlots(nullptr)
{}
safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR(const safe_VkVideoDecodeInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
codedOffset = copy_src.codedOffset;
codedExtent = copy_src.codedExtent;
srcBuffer = copy_src.srcBuffer;
srcBufferOffset = copy_src.srcBufferOffset;
srcBufferRange = copy_src.srcBufferRange;
dstPictureResource.initialize(&copy_src.dstPictureResource);
pSetupReferenceSlot = nullptr;
referenceSlotCount = copy_src.referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(*copy_src.pSetupReferenceSlot);
if (referenceSlotCount && copy_src.pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
}
}
}
safe_VkVideoDecodeInfoKHR& safe_VkVideoDecodeInfoKHR::operator=(const safe_VkVideoDecodeInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pSetupReferenceSlot)
delete pSetupReferenceSlot;
if (pReferenceSlots)
delete[] pReferenceSlots;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
codedOffset = copy_src.codedOffset;
codedExtent = copy_src.codedExtent;
srcBuffer = copy_src.srcBuffer;
srcBufferOffset = copy_src.srcBufferOffset;
srcBufferRange = copy_src.srcBufferRange;
dstPictureResource.initialize(&copy_src.dstPictureResource);
pSetupReferenceSlot = nullptr;
referenceSlotCount = copy_src.referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(*copy_src.pSetupReferenceSlot);
if (referenceSlotCount && copy_src.pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
}
}
return *this;
}
safe_VkVideoDecodeInfoKHR::~safe_VkVideoDecodeInfoKHR()
{
if (pSetupReferenceSlot)
delete pSetupReferenceSlot;
if (pReferenceSlots)
delete[] pReferenceSlots;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeInfoKHR::initialize(const VkVideoDecodeInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
codedOffset = in_struct->codedOffset;
codedExtent = in_struct->codedExtent;
srcBuffer = in_struct->srcBuffer;
srcBufferOffset = in_struct->srcBufferOffset;
srcBufferRange = in_struct->srcBufferRange;
dstPictureResource.initialize(&in_struct->dstPictureResource);
pSetupReferenceSlot = nullptr;
referenceSlotCount = in_struct->referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(in_struct->pSetupReferenceSlot);
if (referenceSlotCount && in_struct->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
}
}
}
void safe_VkVideoDecodeInfoKHR::initialize(const safe_VkVideoDecodeInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
codedOffset = copy_src->codedOffset;
codedExtent = copy_src->codedExtent;
srcBuffer = copy_src->srcBuffer;
srcBufferOffset = copy_src->srcBufferOffset;
srcBufferRange = copy_src->srcBufferRange;
dstPictureResource.initialize(&copy_src->dstPictureResource);
pSetupReferenceSlot = nullptr;
referenceSlotCount = copy_src->referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(*copy_src->pSetupReferenceSlot);
if (referenceSlotCount && copy_src->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
}
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
handleType(in_struct->handleType),
handle(in_struct->handle),
name(in_struct->name)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR),
pNext(nullptr)
{}
safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
handleType = copy_src.handleType;
handle = copy_src.handle;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportMemoryWin32HandleInfoKHR& safe_VkImportMemoryWin32HandleInfoKHR::operator=(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleType = copy_src.handleType;
handle = copy_src.handle;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportMemoryWin32HandleInfoKHR::~safe_VkImportMemoryWin32HandleInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
handleType = in_struct->handleType;
handle = in_struct->handle;
name = in_struct->name;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
handleType = copy_src->handleType;
handle = copy_src->handle;
name = copy_src->name;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
pAttributes(nullptr),
dwAccess(in_struct->dwAccess),
name(in_struct->name)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
}
}
safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR),
pNext(nullptr),
pAttributes(nullptr)
{}
safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
pAttributes = nullptr;
dwAccess = copy_src.dwAccess;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
}
}
safe_VkExportMemoryWin32HandleInfoKHR& safe_VkExportMemoryWin32HandleInfoKHR::operator=(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pAttributes)
delete pAttributes;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pAttributes = nullptr;
dwAccess = copy_src.dwAccess;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
}
return *this;
}
safe_VkExportMemoryWin32HandleInfoKHR::~safe_VkExportMemoryWin32HandleInfoKHR()
{
if (pAttributes)
delete pAttributes;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
pAttributes = nullptr;
dwAccess = in_struct->dwAccess;
name = in_struct->name;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
}
}
void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
pAttributes = nullptr;
dwAccess = copy_src->dwAccess;
name = copy_src->name;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
}
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct) :
sType(in_struct->sType),
memoryTypeBits(in_struct->memoryTypeBits)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR() :
sType(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src)
{
sType = copy_src.sType;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryWin32HandlePropertiesKHR& safe_VkMemoryWin32HandlePropertiesKHR::operator=(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryWin32HandlePropertiesKHR::~safe_VkMemoryWin32HandlePropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct)
{
sType = in_struct->sType;
memoryTypeBits = in_struct->memoryTypeBits;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src)
{
sType = copy_src->sType;
memoryTypeBits = copy_src->memoryTypeBits;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
memory(in_struct->memory),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR),
pNext(nullptr)
{}
safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
memory = copy_src.memory;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryGetWin32HandleInfoKHR& safe_VkMemoryGetWin32HandleInfoKHR::operator=(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memory = copy_src.memory;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryGetWin32HandleInfoKHR::~safe_VkMemoryGetWin32HandleInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
memory = in_struct->memory;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
memory = copy_src->memory;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct) :
sType(in_struct->sType),
handleType(in_struct->handleType),
fd(in_struct->fd)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR() :
sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR),
pNext(nullptr)
{}
safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src)
{
sType = copy_src.sType;
handleType = copy_src.handleType;
fd = copy_src.fd;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportMemoryFdInfoKHR& safe_VkImportMemoryFdInfoKHR::operator=(const safe_VkImportMemoryFdInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleType = copy_src.handleType;
fd = copy_src.fd;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportMemoryFdInfoKHR::~safe_VkImportMemoryFdInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportMemoryFdInfoKHR::initialize(const VkImportMemoryFdInfoKHR* in_struct)
{
sType = in_struct->sType;
handleType = in_struct->handleType;
fd = in_struct->fd;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportMemoryFdInfoKHR::initialize(const safe_VkImportMemoryFdInfoKHR* copy_src)
{
sType = copy_src->sType;
handleType = copy_src->handleType;
fd = copy_src->fd;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct) :
sType(in_struct->sType),
memoryTypeBits(in_struct->memoryTypeBits)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR() :
sType(VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src)
{
sType = copy_src.sType;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryFdPropertiesKHR& safe_VkMemoryFdPropertiesKHR::operator=(const safe_VkMemoryFdPropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryFdPropertiesKHR::~safe_VkMemoryFdPropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryFdPropertiesKHR::initialize(const VkMemoryFdPropertiesKHR* in_struct)
{
sType = in_struct->sType;
memoryTypeBits = in_struct->memoryTypeBits;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryFdPropertiesKHR::initialize(const safe_VkMemoryFdPropertiesKHR* copy_src)
{
sType = copy_src->sType;
memoryTypeBits = copy_src->memoryTypeBits;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct) :
sType(in_struct->sType),
memory(in_struct->memory),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR() :
sType(VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR),
pNext(nullptr)
{}
safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src)
{
sType = copy_src.sType;
memory = copy_src.memory;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryGetFdInfoKHR& safe_VkMemoryGetFdInfoKHR::operator=(const safe_VkMemoryGetFdInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memory = copy_src.memory;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryGetFdInfoKHR::~safe_VkMemoryGetFdInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryGetFdInfoKHR::initialize(const VkMemoryGetFdInfoKHR* in_struct)
{
sType = in_struct->sType;
memory = in_struct->memory;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryGetFdInfoKHR::initialize(const safe_VkMemoryGetFdInfoKHR* copy_src)
{
sType = copy_src->sType;
memory = copy_src->memory;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct) :
sType(in_struct->sType),
acquireCount(in_struct->acquireCount),
pAcquireSyncs(nullptr),
pAcquireKeys(nullptr),
pAcquireTimeouts(nullptr),
releaseCount(in_struct->releaseCount),
pReleaseSyncs(nullptr),
pReleaseKeys(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (acquireCount && in_struct->pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
}
}
if (in_struct->pAcquireKeys) {
pAcquireKeys = new uint64_t[in_struct->acquireCount];
memcpy ((void *)pAcquireKeys, (void *)in_struct->pAcquireKeys, sizeof(uint64_t)*in_struct->acquireCount);
}
if (in_struct->pAcquireTimeouts) {
pAcquireTimeouts = new uint32_t[in_struct->acquireCount];
memcpy ((void *)pAcquireTimeouts, (void *)in_struct->pAcquireTimeouts, sizeof(uint32_t)*in_struct->acquireCount);
}
if (releaseCount && in_struct->pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
}
}
if (in_struct->pReleaseKeys) {
pReleaseKeys = new uint64_t[in_struct->releaseCount];
memcpy ((void *)pReleaseKeys, (void *)in_struct->pReleaseKeys, sizeof(uint64_t)*in_struct->releaseCount);
}
}
safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() :
sType(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR),
pNext(nullptr),
pAcquireSyncs(nullptr),
pAcquireKeys(nullptr),
pAcquireTimeouts(nullptr),
pReleaseSyncs(nullptr),
pReleaseKeys(nullptr)
{}
safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src)
{
sType = copy_src.sType;
acquireCount = copy_src.acquireCount;
pAcquireSyncs = nullptr;
pAcquireKeys = nullptr;
pAcquireTimeouts = nullptr;
releaseCount = copy_src.releaseCount;
pReleaseSyncs = nullptr;
pReleaseKeys = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (acquireCount && copy_src.pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
}
}
if (copy_src.pAcquireKeys) {
pAcquireKeys = new uint64_t[copy_src.acquireCount];
memcpy ((void *)pAcquireKeys, (void *)copy_src.pAcquireKeys, sizeof(uint64_t)*copy_src.acquireCount);
}
if (copy_src.pAcquireTimeouts) {
pAcquireTimeouts = new uint32_t[copy_src.acquireCount];
memcpy ((void *)pAcquireTimeouts, (void *)copy_src.pAcquireTimeouts, sizeof(uint32_t)*copy_src.acquireCount);
}
if (releaseCount && copy_src.pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
}
}
if (copy_src.pReleaseKeys) {
pReleaseKeys = new uint64_t[copy_src.releaseCount];
memcpy ((void *)pReleaseKeys, (void *)copy_src.pReleaseKeys, sizeof(uint64_t)*copy_src.releaseCount);
}
}
safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pAcquireSyncs)
delete[] pAcquireSyncs;
if (pAcquireKeys)
delete[] pAcquireKeys;
if (pAcquireTimeouts)
delete[] pAcquireTimeouts;
if (pReleaseSyncs)
delete[] pReleaseSyncs;
if (pReleaseKeys)
delete[] pReleaseKeys;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
acquireCount = copy_src.acquireCount;
pAcquireSyncs = nullptr;
pAcquireKeys = nullptr;
pAcquireTimeouts = nullptr;
releaseCount = copy_src.releaseCount;
pReleaseSyncs = nullptr;
pReleaseKeys = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (acquireCount && copy_src.pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
}
}
if (copy_src.pAcquireKeys) {
pAcquireKeys = new uint64_t[copy_src.acquireCount];
memcpy ((void *)pAcquireKeys, (void *)copy_src.pAcquireKeys, sizeof(uint64_t)*copy_src.acquireCount);
}
if (copy_src.pAcquireTimeouts) {
pAcquireTimeouts = new uint32_t[copy_src.acquireCount];
memcpy ((void *)pAcquireTimeouts, (void *)copy_src.pAcquireTimeouts, sizeof(uint32_t)*copy_src.acquireCount);
}
if (releaseCount && copy_src.pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
}
}
if (copy_src.pReleaseKeys) {
pReleaseKeys = new uint64_t[copy_src.releaseCount];
memcpy ((void *)pReleaseKeys, (void *)copy_src.pReleaseKeys, sizeof(uint64_t)*copy_src.releaseCount);
}
return *this;
}
safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR()
{
if (pAcquireSyncs)
delete[] pAcquireSyncs;
if (pAcquireKeys)
delete[] pAcquireKeys;
if (pAcquireTimeouts)
delete[] pAcquireTimeouts;
if (pReleaseSyncs)
delete[] pReleaseSyncs;
if (pReleaseKeys)
delete[] pReleaseKeys;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct)
{
sType = in_struct->sType;
acquireCount = in_struct->acquireCount;
pAcquireSyncs = nullptr;
pAcquireKeys = nullptr;
pAcquireTimeouts = nullptr;
releaseCount = in_struct->releaseCount;
pReleaseSyncs = nullptr;
pReleaseKeys = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (acquireCount && in_struct->pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
}
}
if (in_struct->pAcquireKeys) {
pAcquireKeys = new uint64_t[in_struct->acquireCount];
memcpy ((void *)pAcquireKeys, (void *)in_struct->pAcquireKeys, sizeof(uint64_t)*in_struct->acquireCount);
}
if (in_struct->pAcquireTimeouts) {
pAcquireTimeouts = new uint32_t[in_struct->acquireCount];
memcpy ((void *)pAcquireTimeouts, (void *)in_struct->pAcquireTimeouts, sizeof(uint32_t)*in_struct->acquireCount);
}
if (releaseCount && in_struct->pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
}
}
if (in_struct->pReleaseKeys) {
pReleaseKeys = new uint64_t[in_struct->releaseCount];
memcpy ((void *)pReleaseKeys, (void *)in_struct->pReleaseKeys, sizeof(uint64_t)*in_struct->releaseCount);
}
}
void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src)
{
sType = copy_src->sType;
acquireCount = copy_src->acquireCount;
pAcquireSyncs = nullptr;
pAcquireKeys = nullptr;
pAcquireTimeouts = nullptr;
releaseCount = copy_src->releaseCount;
pReleaseSyncs = nullptr;
pReleaseKeys = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (acquireCount && copy_src->pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = copy_src->pAcquireSyncs[i];
}
}
if (copy_src->pAcquireKeys) {
pAcquireKeys = new uint64_t[copy_src->acquireCount];
memcpy ((void *)pAcquireKeys, (void *)copy_src->pAcquireKeys, sizeof(uint64_t)*copy_src->acquireCount);
}
if (copy_src->pAcquireTimeouts) {
pAcquireTimeouts = new uint32_t[copy_src->acquireCount];
memcpy ((void *)pAcquireTimeouts, (void *)copy_src->pAcquireTimeouts, sizeof(uint32_t)*copy_src->acquireCount);
}
if (releaseCount && copy_src->pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = copy_src->pReleaseSyncs[i];
}
}
if (copy_src->pReleaseKeys) {
pReleaseKeys = new uint64_t[copy_src->releaseCount];
memcpy ((void *)pReleaseKeys, (void *)copy_src->pReleaseKeys, sizeof(uint64_t)*copy_src->releaseCount);
}
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
semaphore(in_struct->semaphore),
flags(in_struct->flags),
handleType(in_struct->handleType),
handle(in_struct->handle),
name(in_struct->name)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR),
pNext(nullptr)
{}
safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
semaphore = copy_src.semaphore;
flags = copy_src.flags;
handleType = copy_src.handleType;
handle = copy_src.handle;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportSemaphoreWin32HandleInfoKHR& safe_VkImportSemaphoreWin32HandleInfoKHR::operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphore = copy_src.semaphore;
flags = copy_src.flags;
handleType = copy_src.handleType;
handle = copy_src.handle;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportSemaphoreWin32HandleInfoKHR::~safe_VkImportSemaphoreWin32HandleInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
semaphore = in_struct->semaphore;
flags = in_struct->flags;
handleType = in_struct->handleType;
handle = in_struct->handle;
name = in_struct->name;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
semaphore = copy_src->semaphore;
flags = copy_src->flags;
handleType = copy_src->handleType;
handle = copy_src->handle;
name = copy_src->name;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
pAttributes(nullptr),
dwAccess(in_struct->dwAccess),
name(in_struct->name)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
}
}
safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR),
pNext(nullptr),
pAttributes(nullptr)
{}
safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
pAttributes = nullptr;
dwAccess = copy_src.dwAccess;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
}
}
safe_VkExportSemaphoreWin32HandleInfoKHR& safe_VkExportSemaphoreWin32HandleInfoKHR::operator=(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pAttributes)
delete pAttributes;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pAttributes = nullptr;
dwAccess = copy_src.dwAccess;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
}
return *this;
}
safe_VkExportSemaphoreWin32HandleInfoKHR::~safe_VkExportSemaphoreWin32HandleInfoKHR()
{
if (pAttributes)
delete pAttributes;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
pAttributes = nullptr;
dwAccess = in_struct->dwAccess;
name = in_struct->name;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
}
}
void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
pAttributes = nullptr;
dwAccess = copy_src->dwAccess;
name = copy_src->name;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
}
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct) :
sType(in_struct->sType),
waitSemaphoreValuesCount(in_struct->waitSemaphoreValuesCount),
pWaitSemaphoreValues(nullptr),
signalSemaphoreValuesCount(in_struct->signalSemaphoreValuesCount),
pSignalSemaphoreValues(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)in_struct->pWaitSemaphoreValues, sizeof(uint64_t)*in_struct->waitSemaphoreValuesCount);
}
if (in_struct->pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)in_struct->pSignalSemaphoreValues, sizeof(uint64_t)*in_struct->signalSemaphoreValuesCount);
}
}
safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR() :
sType(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR),
pNext(nullptr),
pWaitSemaphoreValues(nullptr),
pSignalSemaphoreValues(nullptr)
{}
safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src)
{
sType = copy_src.sType;
waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount;
pWaitSemaphoreValues = nullptr;
signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount;
pSignalSemaphoreValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)copy_src.pWaitSemaphoreValues, sizeof(uint64_t)*copy_src.waitSemaphoreValuesCount);
}
if (copy_src.pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)copy_src.pSignalSemaphoreValues, sizeof(uint64_t)*copy_src.signalSemaphoreValuesCount);
}
}
safe_VkD3D12FenceSubmitInfoKHR& safe_VkD3D12FenceSubmitInfoKHR::operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pWaitSemaphoreValues)
delete[] pWaitSemaphoreValues;
if (pSignalSemaphoreValues)
delete[] pSignalSemaphoreValues;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount;
pWaitSemaphoreValues = nullptr;
signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount;
pSignalSemaphoreValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)copy_src.pWaitSemaphoreValues, sizeof(uint64_t)*copy_src.waitSemaphoreValuesCount);
}
if (copy_src.pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)copy_src.pSignalSemaphoreValues, sizeof(uint64_t)*copy_src.signalSemaphoreValuesCount);
}
return *this;
}
safe_VkD3D12FenceSubmitInfoKHR::~safe_VkD3D12FenceSubmitInfoKHR()
{
if (pWaitSemaphoreValues)
delete[] pWaitSemaphoreValues;
if (pSignalSemaphoreValues)
delete[] pSignalSemaphoreValues;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkD3D12FenceSubmitInfoKHR::initialize(const VkD3D12FenceSubmitInfoKHR* in_struct)
{
sType = in_struct->sType;
waitSemaphoreValuesCount = in_struct->waitSemaphoreValuesCount;
pWaitSemaphoreValues = nullptr;
signalSemaphoreValuesCount = in_struct->signalSemaphoreValuesCount;
pSignalSemaphoreValues = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)in_struct->pWaitSemaphoreValues, sizeof(uint64_t)*in_struct->waitSemaphoreValuesCount);
}
if (in_struct->pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)in_struct->pSignalSemaphoreValues, sizeof(uint64_t)*in_struct->signalSemaphoreValuesCount);
}
}
void safe_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src)
{
sType = copy_src->sType;
waitSemaphoreValuesCount = copy_src->waitSemaphoreValuesCount;
pWaitSemaphoreValues = nullptr;
signalSemaphoreValuesCount = copy_src->signalSemaphoreValuesCount;
pSignalSemaphoreValues = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pWaitSemaphoreValues) {
pWaitSemaphoreValues = new uint64_t[copy_src->waitSemaphoreValuesCount];
memcpy ((void *)pWaitSemaphoreValues, (void *)copy_src->pWaitSemaphoreValues, sizeof(uint64_t)*copy_src->waitSemaphoreValuesCount);
}
if (copy_src->pSignalSemaphoreValues) {
pSignalSemaphoreValues = new uint64_t[copy_src->signalSemaphoreValuesCount];
memcpy ((void *)pSignalSemaphoreValues, (void *)copy_src->pSignalSemaphoreValues, sizeof(uint64_t)*copy_src->signalSemaphoreValuesCount);
}
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
semaphore(in_struct->semaphore),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR),
pNext(nullptr)
{}
safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
semaphore = copy_src.semaphore;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSemaphoreGetWin32HandleInfoKHR& safe_VkSemaphoreGetWin32HandleInfoKHR::operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphore = copy_src.semaphore;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSemaphoreGetWin32HandleInfoKHR::~safe_VkSemaphoreGetWin32HandleInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
semaphore = in_struct->semaphore;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
semaphore = copy_src->semaphore;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct) :
sType(in_struct->sType),
semaphore(in_struct->semaphore),
flags(in_struct->flags),
handleType(in_struct->handleType),
fd(in_struct->fd)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR() :
sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR),
pNext(nullptr)
{}
safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src)
{
sType = copy_src.sType;
semaphore = copy_src.semaphore;
flags = copy_src.flags;
handleType = copy_src.handleType;
fd = copy_src.fd;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportSemaphoreFdInfoKHR& safe_VkImportSemaphoreFdInfoKHR::operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphore = copy_src.semaphore;
flags = copy_src.flags;
handleType = copy_src.handleType;
fd = copy_src.fd;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportSemaphoreFdInfoKHR::~safe_VkImportSemaphoreFdInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportSemaphoreFdInfoKHR::initialize(const VkImportSemaphoreFdInfoKHR* in_struct)
{
sType = in_struct->sType;
semaphore = in_struct->semaphore;
flags = in_struct->flags;
handleType = in_struct->handleType;
fd = in_struct->fd;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportSemaphoreFdInfoKHR::initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src)
{
sType = copy_src->sType;
semaphore = copy_src->semaphore;
flags = copy_src->flags;
handleType = copy_src->handleType;
fd = copy_src->fd;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct) :
sType(in_struct->sType),
semaphore(in_struct->semaphore),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR() :
sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR),
pNext(nullptr)
{}
safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src)
{
sType = copy_src.sType;
semaphore = copy_src.semaphore;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSemaphoreGetFdInfoKHR& safe_VkSemaphoreGetFdInfoKHR::operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphore = copy_src.semaphore;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSemaphoreGetFdInfoKHR::~safe_VkSemaphoreGetFdInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSemaphoreGetFdInfoKHR::initialize(const VkSemaphoreGetFdInfoKHR* in_struct)
{
sType = in_struct->sType;
semaphore = in_struct->semaphore;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src)
{
sType = copy_src->sType;
semaphore = copy_src->semaphore;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct) :
sType(in_struct->sType),
maxPushDescriptors(in_struct->maxPushDescriptors)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src)
{
sType = copy_src.sType;
maxPushDescriptors = copy_src.maxPushDescriptors;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxPushDescriptors = copy_src.maxPushDescriptors;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct)
{
sType = in_struct->sType;
maxPushDescriptors = in_struct->maxPushDescriptors;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src)
{
sType = copy_src->sType;
maxPushDescriptors = copy_src->maxPushDescriptors;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct) :
rectangleCount(in_struct->rectangleCount),
pRectangles(nullptr)
{
if (in_struct->pRectangles) {
pRectangles = new VkRectLayerKHR[in_struct->rectangleCount];
memcpy ((void *)pRectangles, (void *)in_struct->pRectangles, sizeof(VkRectLayerKHR)*in_struct->rectangleCount);
}
}
safe_VkPresentRegionKHR::safe_VkPresentRegionKHR() :
pRectangles(nullptr)
{}
safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src)
{
rectangleCount = copy_src.rectangleCount;
pRectangles = nullptr;
if (copy_src.pRectangles) {
pRectangles = new VkRectLayerKHR[copy_src.rectangleCount];
memcpy ((void *)pRectangles, (void *)copy_src.pRectangles, sizeof(VkRectLayerKHR)*copy_src.rectangleCount);
}
}
safe_VkPresentRegionKHR& safe_VkPresentRegionKHR::operator=(const safe_VkPresentRegionKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pRectangles)
delete[] pRectangles;
rectangleCount = copy_src.rectangleCount;
pRectangles = nullptr;
if (copy_src.pRectangles) {
pRectangles = new VkRectLayerKHR[copy_src.rectangleCount];
memcpy ((void *)pRectangles, (void *)copy_src.pRectangles, sizeof(VkRectLayerKHR)*copy_src.rectangleCount);
}
return *this;
}
safe_VkPresentRegionKHR::~safe_VkPresentRegionKHR()
{
if (pRectangles)
delete[] pRectangles;
}
void safe_VkPresentRegionKHR::initialize(const VkPresentRegionKHR* in_struct)
{
rectangleCount = in_struct->rectangleCount;
pRectangles = nullptr;
if (in_struct->pRectangles) {
pRectangles = new VkRectLayerKHR[in_struct->rectangleCount];
memcpy ((void *)pRectangles, (void *)in_struct->pRectangles, sizeof(VkRectLayerKHR)*in_struct->rectangleCount);
}
}
void safe_VkPresentRegionKHR::initialize(const safe_VkPresentRegionKHR* copy_src)
{
rectangleCount = copy_src->rectangleCount;
pRectangles = nullptr;
if (copy_src->pRectangles) {
pRectangles = new VkRectLayerKHR[copy_src->rectangleCount];
memcpy ((void *)pRectangles, (void *)copy_src->pRectangles, sizeof(VkRectLayerKHR)*copy_src->rectangleCount);
}
}
safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct) :
sType(in_struct->sType),
swapchainCount(in_struct->swapchainCount),
pRegions(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (swapchainCount && in_struct->pRegions) {
pRegions = new safe_VkPresentRegionKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR() :
sType(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR),
pNext(nullptr),
pRegions(nullptr)
{}
safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src)
{
sType = copy_src.sType;
swapchainCount = copy_src.swapchainCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (swapchainCount && copy_src.pRegions) {
pRegions = new safe_VkPresentRegionKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
}
safe_VkPresentRegionsKHR& safe_VkPresentRegionsKHR::operator=(const safe_VkPresentRegionsKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
swapchainCount = copy_src.swapchainCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (swapchainCount && copy_src.pRegions) {
pRegions = new safe_VkPresentRegionKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
return *this;
}
safe_VkPresentRegionsKHR::~safe_VkPresentRegionsKHR()
{
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct)
{
sType = in_struct->sType;
swapchainCount = in_struct->swapchainCount;
pRegions = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (swapchainCount && in_struct->pRegions) {
pRegions = new safe_VkPresentRegionKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
void safe_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* copy_src)
{
sType = copy_src->sType;
swapchainCount = copy_src->swapchainCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (swapchainCount && copy_src->pRegions) {
pRegions = new safe_VkPresentRegionKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
pRegions[i].initialize(&copy_src->pRegions[i]);
}
}
}
safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct) :
sType(in_struct->sType),
sharedPresentSupportedUsageFlags(in_struct->sharedPresentSupportedUsageFlags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR() :
sType(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR),
pNext(nullptr)
{}
safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src)
{
sType = copy_src.sType;
sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSharedPresentSurfaceCapabilitiesKHR& safe_VkSharedPresentSurfaceCapabilitiesKHR::operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSharedPresentSurfaceCapabilitiesKHR::~safe_VkSharedPresentSurfaceCapabilitiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct)
{
sType = in_struct->sType;
sharedPresentSupportedUsageFlags = in_struct->sharedPresentSupportedUsageFlags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src)
{
sType = copy_src->sType;
sharedPresentSupportedUsageFlags = copy_src->sharedPresentSupportedUsageFlags;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
fence(in_struct->fence),
flags(in_struct->flags),
handleType(in_struct->handleType),
handle(in_struct->handle),
name(in_struct->name)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR),
pNext(nullptr)
{}
safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
fence = copy_src.fence;
flags = copy_src.flags;
handleType = copy_src.handleType;
handle = copy_src.handle;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportFenceWin32HandleInfoKHR& safe_VkImportFenceWin32HandleInfoKHR::operator=(const safe_VkImportFenceWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fence = copy_src.fence;
flags = copy_src.flags;
handleType = copy_src.handleType;
handle = copy_src.handle;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportFenceWin32HandleInfoKHR::~safe_VkImportFenceWin32HandleInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportFenceWin32HandleInfoKHR::initialize(const VkImportFenceWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
fence = in_struct->fence;
flags = in_struct->flags;
handleType = in_struct->handleType;
handle = in_struct->handle;
name = in_struct->name;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
fence = copy_src->fence;
flags = copy_src->flags;
handleType = copy_src->handleType;
handle = copy_src->handle;
name = copy_src->name;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
pAttributes(nullptr),
dwAccess(in_struct->dwAccess),
name(in_struct->name)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
}
}
safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR),
pNext(nullptr),
pAttributes(nullptr)
{}
safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
pAttributes = nullptr;
dwAccess = copy_src.dwAccess;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
}
}
safe_VkExportFenceWin32HandleInfoKHR& safe_VkExportFenceWin32HandleInfoKHR::operator=(const safe_VkExportFenceWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pAttributes)
delete pAttributes;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pAttributes = nullptr;
dwAccess = copy_src.dwAccess;
name = copy_src.name;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
}
return *this;
}
safe_VkExportFenceWin32HandleInfoKHR::~safe_VkExportFenceWin32HandleInfoKHR()
{
if (pAttributes)
delete pAttributes;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
pAttributes = nullptr;
dwAccess = in_struct->dwAccess;
name = in_struct->name;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
}
}
void safe_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
pAttributes = nullptr;
dwAccess = copy_src->dwAccess;
name = copy_src->name;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
}
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct) :
sType(in_struct->sType),
fence(in_struct->fence),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR() :
sType(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR),
pNext(nullptr)
{}
safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src)
{
sType = copy_src.sType;
fence = copy_src.fence;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkFenceGetWin32HandleInfoKHR& safe_VkFenceGetWin32HandleInfoKHR::operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fence = copy_src.fence;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkFenceGetWin32HandleInfoKHR::~safe_VkFenceGetWin32HandleInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFenceGetWin32HandleInfoKHR::initialize(const VkFenceGetWin32HandleInfoKHR* in_struct)
{
sType = in_struct->sType;
fence = in_struct->fence;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkFenceGetWin32HandleInfoKHR::initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src)
{
sType = copy_src->sType;
fence = copy_src->fence;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct) :
sType(in_struct->sType),
fence(in_struct->fence),
flags(in_struct->flags),
handleType(in_struct->handleType),
fd(in_struct->fd)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR() :
sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR),
pNext(nullptr)
{}
safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src)
{
sType = copy_src.sType;
fence = copy_src.fence;
flags = copy_src.flags;
handleType = copy_src.handleType;
fd = copy_src.fd;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportFenceFdInfoKHR& safe_VkImportFenceFdInfoKHR::operator=(const safe_VkImportFenceFdInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fence = copy_src.fence;
flags = copy_src.flags;
handleType = copy_src.handleType;
fd = copy_src.fd;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportFenceFdInfoKHR::~safe_VkImportFenceFdInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportFenceFdInfoKHR::initialize(const VkImportFenceFdInfoKHR* in_struct)
{
sType = in_struct->sType;
fence = in_struct->fence;
flags = in_struct->flags;
handleType = in_struct->handleType;
fd = in_struct->fd;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportFenceFdInfoKHR::initialize(const safe_VkImportFenceFdInfoKHR* copy_src)
{
sType = copy_src->sType;
fence = copy_src->fence;
flags = copy_src->flags;
handleType = copy_src->handleType;
fd = copy_src->fd;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct) :
sType(in_struct->sType),
fence(in_struct->fence),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR() :
sType(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR),
pNext(nullptr)
{}
safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src)
{
sType = copy_src.sType;
fence = copy_src.fence;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkFenceGetFdInfoKHR& safe_VkFenceGetFdInfoKHR::operator=(const safe_VkFenceGetFdInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fence = copy_src.fence;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkFenceGetFdInfoKHR::~safe_VkFenceGetFdInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFenceGetFdInfoKHR::initialize(const VkFenceGetFdInfoKHR* in_struct)
{
sType = in_struct->sType;
fence = in_struct->fence;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkFenceGetFdInfoKHR::initialize(const safe_VkFenceGetFdInfoKHR* copy_src)
{
sType = copy_src->sType;
fence = copy_src->fence;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct) :
sType(in_struct->sType),
performanceCounterQueryPools(in_struct->performanceCounterQueryPools),
performanceCounterMultipleQueryPools(in_struct->performanceCounterMultipleQueryPools)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src)
{
sType = copy_src.sType;
performanceCounterQueryPools = copy_src.performanceCounterQueryPools;
performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::operator=(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
performanceCounterQueryPools = copy_src.performanceCounterQueryPools;
performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct)
{
sType = in_struct->sType;
performanceCounterQueryPools = in_struct->performanceCounterQueryPools;
performanceCounterMultipleQueryPools = in_struct->performanceCounterMultipleQueryPools;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src)
{
sType = copy_src->sType;
performanceCounterQueryPools = copy_src->performanceCounterQueryPools;
performanceCounterMultipleQueryPools = copy_src->performanceCounterMultipleQueryPools;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct) :
sType(in_struct->sType),
allowCommandBufferQueryCopies(in_struct->allowCommandBufferQueryCopies)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src)
{
sType = copy_src.sType;
allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::operator=(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct)
{
sType = in_struct->sType;
allowCommandBufferQueryCopies = in_struct->allowCommandBufferQueryCopies;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src)
{
sType = copy_src->sType;
allowCommandBufferQueryCopies = copy_src->allowCommandBufferQueryCopies;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct) :
sType(in_struct->sType),
unit(in_struct->unit),
scope(in_struct->scope),
storage(in_struct->storage)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
uuid[i] = in_struct->uuid[i];
}
}
safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR() :
sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR),
pNext(nullptr)
{}
safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src)
{
sType = copy_src.sType;
unit = copy_src.unit;
scope = copy_src.scope;
storage = copy_src.storage;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
uuid[i] = copy_src.uuid[i];
}
}
safe_VkPerformanceCounterKHR& safe_VkPerformanceCounterKHR::operator=(const safe_VkPerformanceCounterKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
unit = copy_src.unit;
scope = copy_src.scope;
storage = copy_src.storage;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
uuid[i] = copy_src.uuid[i];
}
return *this;
}
safe_VkPerformanceCounterKHR::~safe_VkPerformanceCounterKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPerformanceCounterKHR::initialize(const VkPerformanceCounterKHR* in_struct)
{
sType = in_struct->sType;
unit = in_struct->unit;
scope = in_struct->scope;
storage = in_struct->storage;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
uuid[i] = in_struct->uuid[i];
}
}
void safe_VkPerformanceCounterKHR::initialize(const safe_VkPerformanceCounterKHR* copy_src)
{
sType = copy_src->sType;
unit = copy_src->unit;
scope = copy_src->scope;
storage = copy_src->storage;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
uuid[i] = copy_src->uuid[i];
}
}
safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
category[i] = in_struct->category[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
}
safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR() :
sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR),
pNext(nullptr)
{}
safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR(const safe_VkPerformanceCounterDescriptionKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
category[i] = copy_src.category[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
}
safe_VkPerformanceCounterDescriptionKHR& safe_VkPerformanceCounterDescriptionKHR::operator=(const safe_VkPerformanceCounterDescriptionKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
category[i] = copy_src.category[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
return *this;
}
safe_VkPerformanceCounterDescriptionKHR::~safe_VkPerformanceCounterDescriptionKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPerformanceCounterDescriptionKHR::initialize(const VkPerformanceCounterDescriptionKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
category[i] = in_struct->category[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
}
void safe_VkPerformanceCounterDescriptionKHR::initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
category[i] = copy_src->category[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src->description[i];
}
}
safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* in_struct) :
sType(in_struct->sType),
queueFamilyIndex(in_struct->queueFamilyIndex),
counterIndexCount(in_struct->counterIndexCount),
pCounterIndices(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pCounterIndices) {
pCounterIndices = new uint32_t[in_struct->counterIndexCount];
memcpy ((void *)pCounterIndices, (void *)in_struct->pCounterIndices, sizeof(uint32_t)*in_struct->counterIndexCount);
}
}
safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR),
pNext(nullptr),
pCounterIndices(nullptr)
{}
safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
queueFamilyIndex = copy_src.queueFamilyIndex;
counterIndexCount = copy_src.counterIndexCount;
pCounterIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pCounterIndices) {
pCounterIndices = new uint32_t[copy_src.counterIndexCount];
memcpy ((void *)pCounterIndices, (void *)copy_src.pCounterIndices, sizeof(uint32_t)*copy_src.counterIndexCount);
}
}
safe_VkQueryPoolPerformanceCreateInfoKHR& safe_VkQueryPoolPerformanceCreateInfoKHR::operator=(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pCounterIndices)
delete[] pCounterIndices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
queueFamilyIndex = copy_src.queueFamilyIndex;
counterIndexCount = copy_src.counterIndexCount;
pCounterIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pCounterIndices) {
pCounterIndices = new uint32_t[copy_src.counterIndexCount];
memcpy ((void *)pCounterIndices, (void *)copy_src.pCounterIndices, sizeof(uint32_t)*copy_src.counterIndexCount);
}
return *this;
}
safe_VkQueryPoolPerformanceCreateInfoKHR::~safe_VkQueryPoolPerformanceCreateInfoKHR()
{
if (pCounterIndices)
delete[] pCounterIndices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
queueFamilyIndex = in_struct->queueFamilyIndex;
counterIndexCount = in_struct->counterIndexCount;
pCounterIndices = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pCounterIndices) {
pCounterIndices = new uint32_t[in_struct->counterIndexCount];
memcpy ((void *)pCounterIndices, (void *)in_struct->pCounterIndices, sizeof(uint32_t)*in_struct->counterIndexCount);
}
}
void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
queueFamilyIndex = copy_src->queueFamilyIndex;
counterIndexCount = copy_src->counterIndexCount;
pCounterIndices = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pCounterIndices) {
pCounterIndices = new uint32_t[copy_src->counterIndexCount];
memcpy ((void *)pCounterIndices, (void *)copy_src->pCounterIndices, sizeof(uint32_t)*copy_src->counterIndexCount);
}
}
safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
timeout(in_struct->timeout)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR() :
sType(VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR),
pNext(nullptr)
{}
safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
timeout = copy_src.timeout;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAcquireProfilingLockInfoKHR& safe_VkAcquireProfilingLockInfoKHR::operator=(const safe_VkAcquireProfilingLockInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
timeout = copy_src.timeout;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAcquireProfilingLockInfoKHR::~safe_VkAcquireProfilingLockInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAcquireProfilingLockInfoKHR::initialize(const VkAcquireProfilingLockInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
timeout = in_struct->timeout;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAcquireProfilingLockInfoKHR::initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
timeout = copy_src->timeout;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct) :
sType(in_struct->sType),
counterPassIndex(in_struct->counterPassIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR() :
sType(VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR),
pNext(nullptr)
{}
safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src)
{
sType = copy_src.sType;
counterPassIndex = copy_src.counterPassIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPerformanceQuerySubmitInfoKHR& safe_VkPerformanceQuerySubmitInfoKHR::operator=(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
counterPassIndex = copy_src.counterPassIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPerformanceQuerySubmitInfoKHR::~safe_VkPerformanceQuerySubmitInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct)
{
sType = in_struct->sType;
counterPassIndex = in_struct->counterPassIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src)
{
sType = copy_src->sType;
counterPassIndex = copy_src->counterPassIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct) :
sType(in_struct->sType),
surface(in_struct->surface)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src)
{
sType = copy_src.sType;
surface = copy_src.surface;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSurfaceInfo2KHR& safe_VkPhysicalDeviceSurfaceInfo2KHR::operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
surface = copy_src.surface;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSurfaceInfo2KHR::~safe_VkPhysicalDeviceSurfaceInfo2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct)
{
sType = in_struct->sType;
surface = in_struct->surface;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src)
{
sType = copy_src->sType;
surface = copy_src->surface;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct) :
sType(in_struct->sType),
surfaceCapabilities(in_struct->surfaceCapabilities)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR() :
sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR),
pNext(nullptr)
{}
safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src)
{
sType = copy_src.sType;
surfaceCapabilities = copy_src.surfaceCapabilities;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSurfaceCapabilities2KHR& safe_VkSurfaceCapabilities2KHR::operator=(const safe_VkSurfaceCapabilities2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
surfaceCapabilities = copy_src.surfaceCapabilities;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSurfaceCapabilities2KHR::~safe_VkSurfaceCapabilities2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSurfaceCapabilities2KHR::initialize(const VkSurfaceCapabilities2KHR* in_struct)
{
sType = in_struct->sType;
surfaceCapabilities = in_struct->surfaceCapabilities;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSurfaceCapabilities2KHR::initialize(const safe_VkSurfaceCapabilities2KHR* copy_src)
{
sType = copy_src->sType;
surfaceCapabilities = copy_src->surfaceCapabilities;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct) :
sType(in_struct->sType),
surfaceFormat(in_struct->surfaceFormat)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR() :
sType(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR),
pNext(nullptr)
{}
safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src)
{
sType = copy_src.sType;
surfaceFormat = copy_src.surfaceFormat;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSurfaceFormat2KHR& safe_VkSurfaceFormat2KHR::operator=(const safe_VkSurfaceFormat2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
surfaceFormat = copy_src.surfaceFormat;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSurfaceFormat2KHR::~safe_VkSurfaceFormat2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSurfaceFormat2KHR::initialize(const VkSurfaceFormat2KHR* in_struct)
{
sType = in_struct->sType;
surfaceFormat = in_struct->surfaceFormat;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSurfaceFormat2KHR::initialize(const safe_VkSurfaceFormat2KHR* copy_src)
{
sType = copy_src->sType;
surfaceFormat = copy_src->surfaceFormat;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct) :
sType(in_struct->sType),
displayProperties(&in_struct->displayProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR() :
sType(VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR),
pNext(nullptr)
{}
safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src)
{
sType = copy_src.sType;
displayProperties.initialize(&copy_src.displayProperties);
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayProperties2KHR& safe_VkDisplayProperties2KHR::operator=(const safe_VkDisplayProperties2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
displayProperties.initialize(&copy_src.displayProperties);
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayProperties2KHR::~safe_VkDisplayProperties2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayProperties2KHR::initialize(const VkDisplayProperties2KHR* in_struct)
{
sType = in_struct->sType;
displayProperties.initialize(&in_struct->displayProperties);
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayProperties2KHR::initialize(const safe_VkDisplayProperties2KHR* copy_src)
{
sType = copy_src->sType;
displayProperties.initialize(&copy_src->displayProperties);
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct) :
sType(in_struct->sType),
displayPlaneProperties(in_struct->displayPlaneProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR() :
sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR),
pNext(nullptr)
{}
safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src)
{
sType = copy_src.sType;
displayPlaneProperties = copy_src.displayPlaneProperties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayPlaneProperties2KHR& safe_VkDisplayPlaneProperties2KHR::operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
displayPlaneProperties = copy_src.displayPlaneProperties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayPlaneProperties2KHR::~safe_VkDisplayPlaneProperties2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayPlaneProperties2KHR::initialize(const VkDisplayPlaneProperties2KHR* in_struct)
{
sType = in_struct->sType;
displayPlaneProperties = in_struct->displayPlaneProperties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayPlaneProperties2KHR::initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src)
{
sType = copy_src->sType;
displayPlaneProperties = copy_src->displayPlaneProperties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct) :
sType(in_struct->sType),
displayModeProperties(in_struct->displayModeProperties)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR() :
sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR),
pNext(nullptr)
{}
safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src)
{
sType = copy_src.sType;
displayModeProperties = copy_src.displayModeProperties;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayModeProperties2KHR& safe_VkDisplayModeProperties2KHR::operator=(const safe_VkDisplayModeProperties2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
displayModeProperties = copy_src.displayModeProperties;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayModeProperties2KHR::~safe_VkDisplayModeProperties2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayModeProperties2KHR::initialize(const VkDisplayModeProperties2KHR* in_struct)
{
sType = in_struct->sType;
displayModeProperties = in_struct->displayModeProperties;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayModeProperties2KHR::initialize(const safe_VkDisplayModeProperties2KHR* copy_src)
{
sType = copy_src->sType;
displayModeProperties = copy_src->displayModeProperties;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct) :
sType(in_struct->sType),
mode(in_struct->mode),
planeIndex(in_struct->planeIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR() :
sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR),
pNext(nullptr)
{}
safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src)
{
sType = copy_src.sType;
mode = copy_src.mode;
planeIndex = copy_src.planeIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayPlaneInfo2KHR& safe_VkDisplayPlaneInfo2KHR::operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
mode = copy_src.mode;
planeIndex = copy_src.planeIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayPlaneInfo2KHR::~safe_VkDisplayPlaneInfo2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayPlaneInfo2KHR::initialize(const VkDisplayPlaneInfo2KHR* in_struct)
{
sType = in_struct->sType;
mode = in_struct->mode;
planeIndex = in_struct->planeIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayPlaneInfo2KHR::initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src)
{
sType = copy_src->sType;
mode = copy_src->mode;
planeIndex = copy_src->planeIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct) :
sType(in_struct->sType),
capabilities(in_struct->capabilities)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR() :
sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR),
pNext(nullptr)
{}
safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src)
{
sType = copy_src.sType;
capabilities = copy_src.capabilities;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayPlaneCapabilities2KHR& safe_VkDisplayPlaneCapabilities2KHR::operator=(const safe_VkDisplayPlaneCapabilities2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
capabilities = copy_src.capabilities;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayPlaneCapabilities2KHR::~safe_VkDisplayPlaneCapabilities2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayPlaneCapabilities2KHR::initialize(const VkDisplayPlaneCapabilities2KHR* in_struct)
{
sType = in_struct->sType;
capabilities = in_struct->capabilities;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayPlaneCapabilities2KHR::initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src)
{
sType = copy_src->sType;
capabilities = copy_src->capabilities;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct) :
sType(in_struct->sType),
constantAlphaColorBlendFactors(in_struct->constantAlphaColorBlendFactors),
events(in_struct->events),
imageViewFormatReinterpretation(in_struct->imageViewFormatReinterpretation),
imageViewFormatSwizzle(in_struct->imageViewFormatSwizzle),
imageView2DOn3DImage(in_struct->imageView2DOn3DImage),
multisampleArrayImage(in_struct->multisampleArrayImage),
mutableComparisonSamplers(in_struct->mutableComparisonSamplers),
pointPolygons(in_struct->pointPolygons),
samplerMipLodBias(in_struct->samplerMipLodBias),
separateStencilMaskRef(in_struct->separateStencilMaskRef),
shaderSampleRateInterpolationFunctions(in_struct->shaderSampleRateInterpolationFunctions),
tessellationIsolines(in_struct->tessellationIsolines),
tessellationPointMode(in_struct->tessellationPointMode),
triangleFans(in_struct->triangleFans),
vertexAttributeAccessBeyondStride(in_struct->vertexAttributeAccessBeyondStride)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src)
{
sType = copy_src.sType;
constantAlphaColorBlendFactors = copy_src.constantAlphaColorBlendFactors;
events = copy_src.events;
imageViewFormatReinterpretation = copy_src.imageViewFormatReinterpretation;
imageViewFormatSwizzle = copy_src.imageViewFormatSwizzle;
imageView2DOn3DImage = copy_src.imageView2DOn3DImage;
multisampleArrayImage = copy_src.multisampleArrayImage;
mutableComparisonSamplers = copy_src.mutableComparisonSamplers;
pointPolygons = copy_src.pointPolygons;
samplerMipLodBias = copy_src.samplerMipLodBias;
separateStencilMaskRef = copy_src.separateStencilMaskRef;
shaderSampleRateInterpolationFunctions = copy_src.shaderSampleRateInterpolationFunctions;
tessellationIsolines = copy_src.tessellationIsolines;
tessellationPointMode = copy_src.tessellationPointMode;
triangleFans = copy_src.triangleFans;
vertexAttributeAccessBeyondStride = copy_src.vertexAttributeAccessBeyondStride;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::operator=(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
constantAlphaColorBlendFactors = copy_src.constantAlphaColorBlendFactors;
events = copy_src.events;
imageViewFormatReinterpretation = copy_src.imageViewFormatReinterpretation;
imageViewFormatSwizzle = copy_src.imageViewFormatSwizzle;
imageView2DOn3DImage = copy_src.imageView2DOn3DImage;
multisampleArrayImage = copy_src.multisampleArrayImage;
mutableComparisonSamplers = copy_src.mutableComparisonSamplers;
pointPolygons = copy_src.pointPolygons;
samplerMipLodBias = copy_src.samplerMipLodBias;
separateStencilMaskRef = copy_src.separateStencilMaskRef;
shaderSampleRateInterpolationFunctions = copy_src.shaderSampleRateInterpolationFunctions;
tessellationIsolines = copy_src.tessellationIsolines;
tessellationPointMode = copy_src.tessellationPointMode;
triangleFans = copy_src.triangleFans;
vertexAttributeAccessBeyondStride = copy_src.vertexAttributeAccessBeyondStride;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct)
{
sType = in_struct->sType;
constantAlphaColorBlendFactors = in_struct->constantAlphaColorBlendFactors;
events = in_struct->events;
imageViewFormatReinterpretation = in_struct->imageViewFormatReinterpretation;
imageViewFormatSwizzle = in_struct->imageViewFormatSwizzle;
imageView2DOn3DImage = in_struct->imageView2DOn3DImage;
multisampleArrayImage = in_struct->multisampleArrayImage;
mutableComparisonSamplers = in_struct->mutableComparisonSamplers;
pointPolygons = in_struct->pointPolygons;
samplerMipLodBias = in_struct->samplerMipLodBias;
separateStencilMaskRef = in_struct->separateStencilMaskRef;
shaderSampleRateInterpolationFunctions = in_struct->shaderSampleRateInterpolationFunctions;
tessellationIsolines = in_struct->tessellationIsolines;
tessellationPointMode = in_struct->tessellationPointMode;
triangleFans = in_struct->triangleFans;
vertexAttributeAccessBeyondStride = in_struct->vertexAttributeAccessBeyondStride;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src)
{
sType = copy_src->sType;
constantAlphaColorBlendFactors = copy_src->constantAlphaColorBlendFactors;
events = copy_src->events;
imageViewFormatReinterpretation = copy_src->imageViewFormatReinterpretation;
imageViewFormatSwizzle = copy_src->imageViewFormatSwizzle;
imageView2DOn3DImage = copy_src->imageView2DOn3DImage;
multisampleArrayImage = copy_src->multisampleArrayImage;
mutableComparisonSamplers = copy_src->mutableComparisonSamplers;
pointPolygons = copy_src->pointPolygons;
samplerMipLodBias = copy_src->samplerMipLodBias;
separateStencilMaskRef = copy_src->separateStencilMaskRef;
shaderSampleRateInterpolationFunctions = copy_src->shaderSampleRateInterpolationFunctions;
tessellationIsolines = copy_src->tessellationIsolines;
tessellationPointMode = copy_src->tessellationPointMode;
triangleFans = copy_src->triangleFans;
vertexAttributeAccessBeyondStride = copy_src->vertexAttributeAccessBeyondStride;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct) :
sType(in_struct->sType),
minVertexInputBindingStrideAlignment(in_struct->minVertexInputBindingStrideAlignment)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src)
{
sType = copy_src.sType;
minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::operator=(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct)
{
sType = in_struct->sType;
minVertexInputBindingStrideAlignment = in_struct->minVertexInputBindingStrideAlignment;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src)
{
sType = copy_src->sType;
minVertexInputBindingStrideAlignment = copy_src->minVertexInputBindingStrideAlignment;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct) :
sType(in_struct->sType),
shaderSubgroupClock(in_struct->shaderSubgroupClock),
shaderDeviceClock(in_struct->shaderDeviceClock)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src)
{
sType = copy_src.sType;
shaderSubgroupClock = copy_src.shaderSubgroupClock;
shaderDeviceClock = copy_src.shaderDeviceClock;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderClockFeaturesKHR& safe_VkPhysicalDeviceShaderClockFeaturesKHR::operator=(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderSubgroupClock = copy_src.shaderSubgroupClock;
shaderDeviceClock = copy_src.shaderDeviceClock;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderClockFeaturesKHR::~safe_VkPhysicalDeviceShaderClockFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct)
{
sType = in_struct->sType;
shaderSubgroupClock = in_struct->shaderSubgroupClock;
shaderDeviceClock = in_struct->shaderDeviceClock;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src)
{
sType = copy_src->sType;
shaderSubgroupClock = copy_src->shaderSubgroupClock;
shaderDeviceClock = copy_src->shaderDeviceClock;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR::safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* in_struct) :
sType(in_struct->sType),
shaderTerminateInvocation(in_struct->shaderTerminateInvocation)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR::safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR::safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& copy_src)
{
sType = copy_src.sType;
shaderTerminateInvocation = copy_src.shaderTerminateInvocation;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR::operator=(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderTerminateInvocation = copy_src.shaderTerminateInvocation;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR::~safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR::initialize(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* in_struct)
{
sType = in_struct->sType;
shaderTerminateInvocation = in_struct->shaderTerminateInvocation;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* copy_src)
{
sType = copy_src->sType;
shaderTerminateInvocation = copy_src->shaderTerminateInvocation;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR* in_struct) :
sType(in_struct->sType),
pFragmentShadingRateAttachment(nullptr),
shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pFragmentShadingRateAttachment)
pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(in_struct->pFragmentShadingRateAttachment);
}
safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR() :
sType(VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR),
pNext(nullptr),
pFragmentShadingRateAttachment(nullptr)
{}
safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src)
{
sType = copy_src.sType;
pFragmentShadingRateAttachment = nullptr;
shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pFragmentShadingRateAttachment)
pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src.pFragmentShadingRateAttachment);
}
safe_VkFragmentShadingRateAttachmentInfoKHR& safe_VkFragmentShadingRateAttachmentInfoKHR::operator=(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pFragmentShadingRateAttachment)
delete pFragmentShadingRateAttachment;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pFragmentShadingRateAttachment = nullptr;
shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pFragmentShadingRateAttachment)
pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src.pFragmentShadingRateAttachment);
return *this;
}
safe_VkFragmentShadingRateAttachmentInfoKHR::~safe_VkFragmentShadingRateAttachmentInfoKHR()
{
if (pFragmentShadingRateAttachment)
delete pFragmentShadingRateAttachment;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct)
{
sType = in_struct->sType;
pFragmentShadingRateAttachment = nullptr;
shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pFragmentShadingRateAttachment)
pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(in_struct->pFragmentShadingRateAttachment);
}
void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src)
{
sType = copy_src->sType;
pFragmentShadingRateAttachment = nullptr;
shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pFragmentShadingRateAttachment)
pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src->pFragmentShadingRateAttachment);
}
safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct) :
sType(in_struct->sType),
fragmentSize(in_struct->fragmentSize)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = in_struct->combinerOps[i];
}
}
safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
fragmentSize = copy_src.fragmentSize;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = copy_src.combinerOps[i];
}
}
safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::operator=(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fragmentSize = copy_src.fragmentSize;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = copy_src.combinerOps[i];
}
return *this;
}
safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
fragmentSize = in_struct->fragmentSize;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = in_struct->combinerOps[i];
}
}
void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
fragmentSize = copy_src->fragmentSize;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = copy_src->combinerOps[i];
}
}
safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct) :
sType(in_struct->sType),
pipelineFragmentShadingRate(in_struct->pipelineFragmentShadingRate),
primitiveFragmentShadingRate(in_struct->primitiveFragmentShadingRate),
attachmentFragmentShadingRate(in_struct->attachmentFragmentShadingRate)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src)
{
sType = copy_src.sType;
pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate;
primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate;
attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::operator=(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate;
primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate;
attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct)
{
sType = in_struct->sType;
pipelineFragmentShadingRate = in_struct->pipelineFragmentShadingRate;
primitiveFragmentShadingRate = in_struct->primitiveFragmentShadingRate;
attachmentFragmentShadingRate = in_struct->attachmentFragmentShadingRate;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src)
{
sType = copy_src->sType;
pipelineFragmentShadingRate = copy_src->pipelineFragmentShadingRate;
primitiveFragmentShadingRate = copy_src->primitiveFragmentShadingRate;
attachmentFragmentShadingRate = copy_src->attachmentFragmentShadingRate;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct) :
sType(in_struct->sType),
minFragmentShadingRateAttachmentTexelSize(in_struct->minFragmentShadingRateAttachmentTexelSize),
maxFragmentShadingRateAttachmentTexelSize(in_struct->maxFragmentShadingRateAttachmentTexelSize),
maxFragmentShadingRateAttachmentTexelSizeAspectRatio(in_struct->maxFragmentShadingRateAttachmentTexelSizeAspectRatio),
primitiveFragmentShadingRateWithMultipleViewports(in_struct->primitiveFragmentShadingRateWithMultipleViewports),
layeredShadingRateAttachments(in_struct->layeredShadingRateAttachments),
fragmentShadingRateNonTrivialCombinerOps(in_struct->fragmentShadingRateNonTrivialCombinerOps),
maxFragmentSize(in_struct->maxFragmentSize),
maxFragmentSizeAspectRatio(in_struct->maxFragmentSizeAspectRatio),
maxFragmentShadingRateCoverageSamples(in_struct->maxFragmentShadingRateCoverageSamples),
maxFragmentShadingRateRasterizationSamples(in_struct->maxFragmentShadingRateRasterizationSamples),
fragmentShadingRateWithShaderDepthStencilWrites(in_struct->fragmentShadingRateWithShaderDepthStencilWrites),
fragmentShadingRateWithSampleMask(in_struct->fragmentShadingRateWithSampleMask),
fragmentShadingRateWithShaderSampleMask(in_struct->fragmentShadingRateWithShaderSampleMask),
fragmentShadingRateWithConservativeRasterization(in_struct->fragmentShadingRateWithConservativeRasterization),
fragmentShadingRateWithFragmentShaderInterlock(in_struct->fragmentShadingRateWithFragmentShaderInterlock),
fragmentShadingRateWithCustomSampleLocations(in_struct->fragmentShadingRateWithCustomSampleLocations),
fragmentShadingRateStrictMultiplyCombiner(in_struct->fragmentShadingRateStrictMultiplyCombiner)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src)
{
sType = copy_src.sType;
minFragmentShadingRateAttachmentTexelSize = copy_src.minFragmentShadingRateAttachmentTexelSize;
maxFragmentShadingRateAttachmentTexelSize = copy_src.maxFragmentShadingRateAttachmentTexelSize;
maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
primitiveFragmentShadingRateWithMultipleViewports = copy_src.primitiveFragmentShadingRateWithMultipleViewports;
layeredShadingRateAttachments = copy_src.layeredShadingRateAttachments;
fragmentShadingRateNonTrivialCombinerOps = copy_src.fragmentShadingRateNonTrivialCombinerOps;
maxFragmentSize = copy_src.maxFragmentSize;
maxFragmentSizeAspectRatio = copy_src.maxFragmentSizeAspectRatio;
maxFragmentShadingRateCoverageSamples = copy_src.maxFragmentShadingRateCoverageSamples;
maxFragmentShadingRateRasterizationSamples = copy_src.maxFragmentShadingRateRasterizationSamples;
fragmentShadingRateWithShaderDepthStencilWrites = copy_src.fragmentShadingRateWithShaderDepthStencilWrites;
fragmentShadingRateWithSampleMask = copy_src.fragmentShadingRateWithSampleMask;
fragmentShadingRateWithShaderSampleMask = copy_src.fragmentShadingRateWithShaderSampleMask;
fragmentShadingRateWithConservativeRasterization = copy_src.fragmentShadingRateWithConservativeRasterization;
fragmentShadingRateWithFragmentShaderInterlock = copy_src.fragmentShadingRateWithFragmentShaderInterlock;
fragmentShadingRateWithCustomSampleLocations = copy_src.fragmentShadingRateWithCustomSampleLocations;
fragmentShadingRateStrictMultiplyCombiner = copy_src.fragmentShadingRateStrictMultiplyCombiner;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::operator=(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
minFragmentShadingRateAttachmentTexelSize = copy_src.minFragmentShadingRateAttachmentTexelSize;
maxFragmentShadingRateAttachmentTexelSize = copy_src.maxFragmentShadingRateAttachmentTexelSize;
maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
primitiveFragmentShadingRateWithMultipleViewports = copy_src.primitiveFragmentShadingRateWithMultipleViewports;
layeredShadingRateAttachments = copy_src.layeredShadingRateAttachments;
fragmentShadingRateNonTrivialCombinerOps = copy_src.fragmentShadingRateNonTrivialCombinerOps;
maxFragmentSize = copy_src.maxFragmentSize;
maxFragmentSizeAspectRatio = copy_src.maxFragmentSizeAspectRatio;
maxFragmentShadingRateCoverageSamples = copy_src.maxFragmentShadingRateCoverageSamples;
maxFragmentShadingRateRasterizationSamples = copy_src.maxFragmentShadingRateRasterizationSamples;
fragmentShadingRateWithShaderDepthStencilWrites = copy_src.fragmentShadingRateWithShaderDepthStencilWrites;
fragmentShadingRateWithSampleMask = copy_src.fragmentShadingRateWithSampleMask;
fragmentShadingRateWithShaderSampleMask = copy_src.fragmentShadingRateWithShaderSampleMask;
fragmentShadingRateWithConservativeRasterization = copy_src.fragmentShadingRateWithConservativeRasterization;
fragmentShadingRateWithFragmentShaderInterlock = copy_src.fragmentShadingRateWithFragmentShaderInterlock;
fragmentShadingRateWithCustomSampleLocations = copy_src.fragmentShadingRateWithCustomSampleLocations;
fragmentShadingRateStrictMultiplyCombiner = copy_src.fragmentShadingRateStrictMultiplyCombiner;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct)
{
sType = in_struct->sType;
minFragmentShadingRateAttachmentTexelSize = in_struct->minFragmentShadingRateAttachmentTexelSize;
maxFragmentShadingRateAttachmentTexelSize = in_struct->maxFragmentShadingRateAttachmentTexelSize;
maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_struct->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
primitiveFragmentShadingRateWithMultipleViewports = in_struct->primitiveFragmentShadingRateWithMultipleViewports;
layeredShadingRateAttachments = in_struct->layeredShadingRateAttachments;
fragmentShadingRateNonTrivialCombinerOps = in_struct->fragmentShadingRateNonTrivialCombinerOps;
maxFragmentSize = in_struct->maxFragmentSize;
maxFragmentSizeAspectRatio = in_struct->maxFragmentSizeAspectRatio;
maxFragmentShadingRateCoverageSamples = in_struct->maxFragmentShadingRateCoverageSamples;
maxFragmentShadingRateRasterizationSamples = in_struct->maxFragmentShadingRateRasterizationSamples;
fragmentShadingRateWithShaderDepthStencilWrites = in_struct->fragmentShadingRateWithShaderDepthStencilWrites;
fragmentShadingRateWithSampleMask = in_struct->fragmentShadingRateWithSampleMask;
fragmentShadingRateWithShaderSampleMask = in_struct->fragmentShadingRateWithShaderSampleMask;
fragmentShadingRateWithConservativeRasterization = in_struct->fragmentShadingRateWithConservativeRasterization;
fragmentShadingRateWithFragmentShaderInterlock = in_struct->fragmentShadingRateWithFragmentShaderInterlock;
fragmentShadingRateWithCustomSampleLocations = in_struct->fragmentShadingRateWithCustomSampleLocations;
fragmentShadingRateStrictMultiplyCombiner = in_struct->fragmentShadingRateStrictMultiplyCombiner;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src)
{
sType = copy_src->sType;
minFragmentShadingRateAttachmentTexelSize = copy_src->minFragmentShadingRateAttachmentTexelSize;
maxFragmentShadingRateAttachmentTexelSize = copy_src->maxFragmentShadingRateAttachmentTexelSize;
maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
primitiveFragmentShadingRateWithMultipleViewports = copy_src->primitiveFragmentShadingRateWithMultipleViewports;
layeredShadingRateAttachments = copy_src->layeredShadingRateAttachments;
fragmentShadingRateNonTrivialCombinerOps = copy_src->fragmentShadingRateNonTrivialCombinerOps;
maxFragmentSize = copy_src->maxFragmentSize;
maxFragmentSizeAspectRatio = copy_src->maxFragmentSizeAspectRatio;
maxFragmentShadingRateCoverageSamples = copy_src->maxFragmentShadingRateCoverageSamples;
maxFragmentShadingRateRasterizationSamples = copy_src->maxFragmentShadingRateRasterizationSamples;
fragmentShadingRateWithShaderDepthStencilWrites = copy_src->fragmentShadingRateWithShaderDepthStencilWrites;
fragmentShadingRateWithSampleMask = copy_src->fragmentShadingRateWithSampleMask;
fragmentShadingRateWithShaderSampleMask = copy_src->fragmentShadingRateWithShaderSampleMask;
fragmentShadingRateWithConservativeRasterization = copy_src->fragmentShadingRateWithConservativeRasterization;
fragmentShadingRateWithFragmentShaderInterlock = copy_src->fragmentShadingRateWithFragmentShaderInterlock;
fragmentShadingRateWithCustomSampleLocations = copy_src->fragmentShadingRateWithCustomSampleLocations;
fragmentShadingRateStrictMultiplyCombiner = copy_src->fragmentShadingRateStrictMultiplyCombiner;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct) :
sType(in_struct->sType),
sampleCounts(in_struct->sampleCounts),
fragmentSize(in_struct->fragmentSize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src)
{
sType = copy_src.sType;
sampleCounts = copy_src.sampleCounts;
fragmentSize = copy_src.fragmentSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateKHR& safe_VkPhysicalDeviceFragmentShadingRateKHR::operator=(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
sampleCounts = copy_src.sampleCounts;
fragmentSize = copy_src.fragmentSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentShadingRateKHR::~safe_VkPhysicalDeviceFragmentShadingRateKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct)
{
sType = in_struct->sType;
sampleCounts = in_struct->sampleCounts;
fragmentSize = in_struct->fragmentSize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src)
{
sType = copy_src->sType;
sampleCounts = copy_src->sampleCounts;
fragmentSize = copy_src->fragmentSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct) :
sType(in_struct->sType),
supportsProtected(in_struct->supportsProtected)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR() :
sType(VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR),
pNext(nullptr)
{}
safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src)
{
sType = copy_src.sType;
supportsProtected = copy_src.supportsProtected;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSurfaceProtectedCapabilitiesKHR& safe_VkSurfaceProtectedCapabilitiesKHR::operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
supportsProtected = copy_src.supportsProtected;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSurfaceProtectedCapabilitiesKHR::~safe_VkSurfaceProtectedCapabilitiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct)
{
sType = in_struct->sType;
supportsProtected = in_struct->supportsProtected;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src)
{
sType = copy_src->sType;
supportsProtected = copy_src->supportsProtected;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct) :
sType(in_struct->sType),
pipelineExecutableInfo(in_struct->pipelineExecutableInfo)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src)
{
sType = copy_src.sType;
pipelineExecutableInfo = copy_src.pipelineExecutableInfo;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pipelineExecutableInfo = copy_src.pipelineExecutableInfo;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct)
{
sType = in_struct->sType;
pipelineExecutableInfo = in_struct->pipelineExecutableInfo;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src)
{
sType = copy_src->sType;
pipelineExecutableInfo = copy_src->pipelineExecutableInfo;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct) :
sType(in_struct->sType),
pipeline(in_struct->pipeline)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR() :
sType(VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR),
pNext(nullptr)
{}
safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src)
{
sType = copy_src.sType;
pipeline = copy_src.pipeline;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineInfoKHR& safe_VkPipelineInfoKHR::operator=(const safe_VkPipelineInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pipeline = copy_src.pipeline;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineInfoKHR::~safe_VkPipelineInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineInfoKHR::initialize(const VkPipelineInfoKHR* in_struct)
{
sType = in_struct->sType;
pipeline = in_struct->pipeline;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineInfoKHR::initialize(const safe_VkPipelineInfoKHR* copy_src)
{
sType = copy_src->sType;
pipeline = copy_src->pipeline;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct) :
sType(in_struct->sType),
stages(in_struct->stages),
subgroupSize(in_struct->subgroupSize)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
}
safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR() :
sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& copy_src)
{
sType = copy_src.sType;
stages = copy_src.stages;
subgroupSize = copy_src.subgroupSize;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
}
safe_VkPipelineExecutablePropertiesKHR& safe_VkPipelineExecutablePropertiesKHR::operator=(const safe_VkPipelineExecutablePropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stages = copy_src.stages;
subgroupSize = copy_src.subgroupSize;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
return *this;
}
safe_VkPipelineExecutablePropertiesKHR::~safe_VkPipelineExecutablePropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineExecutablePropertiesKHR::initialize(const VkPipelineExecutablePropertiesKHR* in_struct)
{
sType = in_struct->sType;
stages = in_struct->stages;
subgroupSize = in_struct->subgroupSize;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
}
void safe_VkPipelineExecutablePropertiesKHR::initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src)
{
sType = copy_src->sType;
stages = copy_src->stages;
subgroupSize = copy_src->subgroupSize;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src->description[i];
}
}
safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct) :
sType(in_struct->sType),
pipeline(in_struct->pipeline),
executableIndex(in_struct->executableIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR() :
sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR),
pNext(nullptr)
{}
safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src)
{
sType = copy_src.sType;
pipeline = copy_src.pipeline;
executableIndex = copy_src.executableIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineExecutableInfoKHR& safe_VkPipelineExecutableInfoKHR::operator=(const safe_VkPipelineExecutableInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pipeline = copy_src.pipeline;
executableIndex = copy_src.executableIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineExecutableInfoKHR::~safe_VkPipelineExecutableInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineExecutableInfoKHR::initialize(const VkPipelineExecutableInfoKHR* in_struct)
{
sType = in_struct->sType;
pipeline = in_struct->pipeline;
executableIndex = in_struct->executableIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineExecutableInfoKHR::initialize(const safe_VkPipelineExecutableInfoKHR* copy_src)
{
sType = copy_src->sType;
pipeline = copy_src->pipeline;
executableIndex = copy_src->executableIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct) :
sType(in_struct->sType),
format(in_struct->format),
value(in_struct->value)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
}
safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR() :
sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR),
pNext(nullptr)
{}
safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& copy_src)
{
sType = copy_src.sType;
format = copy_src.format;
value = copy_src.value;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
}
safe_VkPipelineExecutableStatisticKHR& safe_VkPipelineExecutableStatisticKHR::operator=(const safe_VkPipelineExecutableStatisticKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
format = copy_src.format;
value = copy_src.value;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
return *this;
}
safe_VkPipelineExecutableStatisticKHR::~safe_VkPipelineExecutableStatisticKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineExecutableStatisticKHR::initialize(const VkPipelineExecutableStatisticKHR* in_struct)
{
sType = in_struct->sType;
format = in_struct->format;
value = in_struct->value;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
}
void safe_VkPipelineExecutableStatisticKHR::initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src)
{
sType = copy_src->sType;
format = copy_src->format;
value = copy_src->value;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src->description[i];
}
}
safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct) :
sType(in_struct->sType),
isText(in_struct->isText),
dataSize(in_struct->dataSize),
pData(in_struct->pData)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
}
safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR() :
sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR),
pNext(nullptr),
pData(nullptr)
{}
safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src)
{
sType = copy_src.sType;
isText = copy_src.isText;
dataSize = copy_src.dataSize;
pData = copy_src.pData;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
}
safe_VkPipelineExecutableInternalRepresentationKHR& safe_VkPipelineExecutableInternalRepresentationKHR::operator=(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
isText = copy_src.isText;
dataSize = copy_src.dataSize;
pData = copy_src.pData;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
return *this;
}
safe_VkPipelineExecutableInternalRepresentationKHR::~safe_VkPipelineExecutableInternalRepresentationKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct)
{
sType = in_struct->sType;
isText = in_struct->isText;
dataSize = in_struct->dataSize;
pData = in_struct->pData;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
}
void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src)
{
sType = copy_src->sType;
isText = copy_src->isText;
dataSize = copy_src->dataSize;
pData = copy_src->pData;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
name[i] = copy_src->name[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src->description[i];
}
}
safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct) :
sType(in_struct->sType),
libraryCount(in_struct->libraryCount),
pLibraries(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (libraryCount && in_struct->pLibraries) {
pLibraries = new VkPipeline[libraryCount];
for (uint32_t i = 0; i < libraryCount; ++i) {
pLibraries[i] = in_struct->pLibraries[i];
}
}
}
safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR),
pNext(nullptr),
pLibraries(nullptr)
{}
safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
libraryCount = copy_src.libraryCount;
pLibraries = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (libraryCount && copy_src.pLibraries) {
pLibraries = new VkPipeline[libraryCount];
for (uint32_t i = 0; i < libraryCount; ++i) {
pLibraries[i] = copy_src.pLibraries[i];
}
}
}
safe_VkPipelineLibraryCreateInfoKHR& safe_VkPipelineLibraryCreateInfoKHR::operator=(const safe_VkPipelineLibraryCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pLibraries)
delete[] pLibraries;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
libraryCount = copy_src.libraryCount;
pLibraries = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (libraryCount && copy_src.pLibraries) {
pLibraries = new VkPipeline[libraryCount];
for (uint32_t i = 0; i < libraryCount; ++i) {
pLibraries[i] = copy_src.pLibraries[i];
}
}
return *this;
}
safe_VkPipelineLibraryCreateInfoKHR::~safe_VkPipelineLibraryCreateInfoKHR()
{
if (pLibraries)
delete[] pLibraries;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineLibraryCreateInfoKHR::initialize(const VkPipelineLibraryCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
libraryCount = in_struct->libraryCount;
pLibraries = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (libraryCount && in_struct->pLibraries) {
pLibraries = new VkPipeline[libraryCount];
for (uint32_t i = 0; i < libraryCount; ++i) {
pLibraries[i] = in_struct->pLibraries[i];
}
}
}
void safe_VkPipelineLibraryCreateInfoKHR::initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
libraryCount = copy_src->libraryCount;
pLibraries = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (libraryCount && copy_src->pLibraries) {
pLibraries = new VkPipeline[libraryCount];
for (uint32_t i = 0; i < libraryCount; ++i) {
pLibraries[i] = copy_src->pLibraries[i];
}
}
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
qualityLevel(in_struct->qualityLevel),
codedExtent(in_struct->codedExtent),
dstBitstreamBuffer(in_struct->dstBitstreamBuffer),
dstBitstreamBufferOffset(in_struct->dstBitstreamBufferOffset),
dstBitstreamBufferMaxRange(in_struct->dstBitstreamBufferMaxRange),
srcPictureResource(&in_struct->srcPictureResource),
pSetupReferenceSlot(nullptr),
referenceSlotCount(in_struct->referenceSlotCount),
pReferenceSlots(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(in_struct->pSetupReferenceSlot);
if (referenceSlotCount && in_struct->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
}
}
}
safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR),
pNext(nullptr),
pSetupReferenceSlot(nullptr),
pReferenceSlots(nullptr)
{}
safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
qualityLevel = copy_src.qualityLevel;
codedExtent = copy_src.codedExtent;
dstBitstreamBuffer = copy_src.dstBitstreamBuffer;
dstBitstreamBufferOffset = copy_src.dstBitstreamBufferOffset;
dstBitstreamBufferMaxRange = copy_src.dstBitstreamBufferMaxRange;
srcPictureResource.initialize(&copy_src.srcPictureResource);
pSetupReferenceSlot = nullptr;
referenceSlotCount = copy_src.referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(*copy_src.pSetupReferenceSlot);
if (referenceSlotCount && copy_src.pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
}
}
}
safe_VkVideoEncodeInfoKHR& safe_VkVideoEncodeInfoKHR::operator=(const safe_VkVideoEncodeInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pSetupReferenceSlot)
delete pSetupReferenceSlot;
if (pReferenceSlots)
delete[] pReferenceSlots;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
qualityLevel = copy_src.qualityLevel;
codedExtent = copy_src.codedExtent;
dstBitstreamBuffer = copy_src.dstBitstreamBuffer;
dstBitstreamBufferOffset = copy_src.dstBitstreamBufferOffset;
dstBitstreamBufferMaxRange = copy_src.dstBitstreamBufferMaxRange;
srcPictureResource.initialize(&copy_src.srcPictureResource);
pSetupReferenceSlot = nullptr;
referenceSlotCount = copy_src.referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(*copy_src.pSetupReferenceSlot);
if (referenceSlotCount && copy_src.pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
}
}
return *this;
}
safe_VkVideoEncodeInfoKHR::~safe_VkVideoEncodeInfoKHR()
{
if (pSetupReferenceSlot)
delete pSetupReferenceSlot;
if (pReferenceSlots)
delete[] pReferenceSlots;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeInfoKHR::initialize(const VkVideoEncodeInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
qualityLevel = in_struct->qualityLevel;
codedExtent = in_struct->codedExtent;
dstBitstreamBuffer = in_struct->dstBitstreamBuffer;
dstBitstreamBufferOffset = in_struct->dstBitstreamBufferOffset;
dstBitstreamBufferMaxRange = in_struct->dstBitstreamBufferMaxRange;
srcPictureResource.initialize(&in_struct->srcPictureResource);
pSetupReferenceSlot = nullptr;
referenceSlotCount = in_struct->referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(in_struct->pSetupReferenceSlot);
if (referenceSlotCount && in_struct->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
}
}
}
void safe_VkVideoEncodeInfoKHR::initialize(const safe_VkVideoEncodeInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
qualityLevel = copy_src->qualityLevel;
codedExtent = copy_src->codedExtent;
dstBitstreamBuffer = copy_src->dstBitstreamBuffer;
dstBitstreamBufferOffset = copy_src->dstBitstreamBufferOffset;
dstBitstreamBufferMaxRange = copy_src->dstBitstreamBufferMaxRange;
srcPictureResource.initialize(&copy_src->srcPictureResource);
pSetupReferenceSlot = nullptr;
referenceSlotCount = copy_src->referenceSlotCount;
pReferenceSlots = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pSetupReferenceSlot)
pSetupReferenceSlot = new safe_VkVideoReferenceSlotKHR(*copy_src->pSetupReferenceSlot);
if (referenceSlotCount && copy_src->pReferenceSlots) {
pReferenceSlots = new safe_VkVideoReferenceSlotKHR[referenceSlotCount];
for (uint32_t i = 0; i < referenceSlotCount; ++i) {
pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
}
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
rateControlMode(in_struct->rateControlMode),
averageBitrate(in_struct->averageBitrate),
peakToAverageBitrateRatio(in_struct->peakToAverageBitrateRatio),
frameRateNumerator(in_struct->frameRateNumerator),
frameRateDenominator(in_struct->frameRateDenominator),
virtualBufferSizeInMs(in_struct->virtualBufferSizeInMs)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR),
pNext(nullptr)
{}
safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
rateControlMode = copy_src.rateControlMode;
averageBitrate = copy_src.averageBitrate;
peakToAverageBitrateRatio = copy_src.peakToAverageBitrateRatio;
frameRateNumerator = copy_src.frameRateNumerator;
frameRateDenominator = copy_src.frameRateDenominator;
virtualBufferSizeInMs = copy_src.virtualBufferSizeInMs;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoEncodeRateControlInfoKHR& safe_VkVideoEncodeRateControlInfoKHR::operator=(const safe_VkVideoEncodeRateControlInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
rateControlMode = copy_src.rateControlMode;
averageBitrate = copy_src.averageBitrate;
peakToAverageBitrateRatio = copy_src.peakToAverageBitrateRatio;
frameRateNumerator = copy_src.frameRateNumerator;
frameRateDenominator = copy_src.frameRateDenominator;
virtualBufferSizeInMs = copy_src.virtualBufferSizeInMs;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoEncodeRateControlInfoKHR::~safe_VkVideoEncodeRateControlInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeRateControlInfoKHR::initialize(const VkVideoEncodeRateControlInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
rateControlMode = in_struct->rateControlMode;
averageBitrate = in_struct->averageBitrate;
peakToAverageBitrateRatio = in_struct->peakToAverageBitrateRatio;
frameRateNumerator = in_struct->frameRateNumerator;
frameRateDenominator = in_struct->frameRateDenominator;
virtualBufferSizeInMs = in_struct->virtualBufferSizeInMs;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoEncodeRateControlInfoKHR::initialize(const safe_VkVideoEncodeRateControlInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
rateControlMode = copy_src->rateControlMode;
averageBitrate = copy_src->averageBitrate;
peakToAverageBitrateRatio = copy_src->peakToAverageBitrateRatio;
frameRateNumerator = copy_src->frameRateNumerator;
frameRateDenominator = copy_src->frameRateDenominator;
virtualBufferSizeInMs = copy_src->virtualBufferSizeInMs;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
safe_VkMemoryBarrier2KHR::safe_VkMemoryBarrier2KHR(const VkMemoryBarrier2KHR* in_struct) :
sType(in_struct->sType),
srcStageMask(in_struct->srcStageMask),
srcAccessMask(in_struct->srcAccessMask),
dstStageMask(in_struct->dstStageMask),
dstAccessMask(in_struct->dstAccessMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryBarrier2KHR::safe_VkMemoryBarrier2KHR() :
sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR),
pNext(nullptr)
{}
safe_VkMemoryBarrier2KHR::safe_VkMemoryBarrier2KHR(const safe_VkMemoryBarrier2KHR& copy_src)
{
sType = copy_src.sType;
srcStageMask = copy_src.srcStageMask;
srcAccessMask = copy_src.srcAccessMask;
dstStageMask = copy_src.dstStageMask;
dstAccessMask = copy_src.dstAccessMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryBarrier2KHR& safe_VkMemoryBarrier2KHR::operator=(const safe_VkMemoryBarrier2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcStageMask = copy_src.srcStageMask;
srcAccessMask = copy_src.srcAccessMask;
dstStageMask = copy_src.dstStageMask;
dstAccessMask = copy_src.dstAccessMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryBarrier2KHR::~safe_VkMemoryBarrier2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryBarrier2KHR::initialize(const VkMemoryBarrier2KHR* in_struct)
{
sType = in_struct->sType;
srcStageMask = in_struct->srcStageMask;
srcAccessMask = in_struct->srcAccessMask;
dstStageMask = in_struct->dstStageMask;
dstAccessMask = in_struct->dstAccessMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryBarrier2KHR::initialize(const safe_VkMemoryBarrier2KHR* copy_src)
{
sType = copy_src->sType;
srcStageMask = copy_src->srcStageMask;
srcAccessMask = copy_src->srcAccessMask;
dstStageMask = copy_src->dstStageMask;
dstAccessMask = copy_src->dstAccessMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBufferMemoryBarrier2KHR::safe_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR* in_struct) :
sType(in_struct->sType),
srcStageMask(in_struct->srcStageMask),
srcAccessMask(in_struct->srcAccessMask),
dstStageMask(in_struct->dstStageMask),
dstAccessMask(in_struct->dstAccessMask),
srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
buffer(in_struct->buffer),
offset(in_struct->offset),
size(in_struct->size)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferMemoryBarrier2KHR::safe_VkBufferMemoryBarrier2KHR() :
sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR),
pNext(nullptr)
{}
safe_VkBufferMemoryBarrier2KHR::safe_VkBufferMemoryBarrier2KHR(const safe_VkBufferMemoryBarrier2KHR& copy_src)
{
sType = copy_src.sType;
srcStageMask = copy_src.srcStageMask;
srcAccessMask = copy_src.srcAccessMask;
dstStageMask = copy_src.dstStageMask;
dstAccessMask = copy_src.dstAccessMask;
srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
buffer = copy_src.buffer;
offset = copy_src.offset;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferMemoryBarrier2KHR& safe_VkBufferMemoryBarrier2KHR::operator=(const safe_VkBufferMemoryBarrier2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcStageMask = copy_src.srcStageMask;
srcAccessMask = copy_src.srcAccessMask;
dstStageMask = copy_src.dstStageMask;
dstAccessMask = copy_src.dstAccessMask;
srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
buffer = copy_src.buffer;
offset = copy_src.offset;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferMemoryBarrier2KHR::~safe_VkBufferMemoryBarrier2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferMemoryBarrier2KHR::initialize(const VkBufferMemoryBarrier2KHR* in_struct)
{
sType = in_struct->sType;
srcStageMask = in_struct->srcStageMask;
srcAccessMask = in_struct->srcAccessMask;
dstStageMask = in_struct->dstStageMask;
dstAccessMask = in_struct->dstAccessMask;
srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
buffer = in_struct->buffer;
offset = in_struct->offset;
size = in_struct->size;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferMemoryBarrier2KHR::initialize(const safe_VkBufferMemoryBarrier2KHR* copy_src)
{
sType = copy_src->sType;
srcStageMask = copy_src->srcStageMask;
srcAccessMask = copy_src->srcAccessMask;
dstStageMask = copy_src->dstStageMask;
dstAccessMask = copy_src->dstAccessMask;
srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
buffer = copy_src->buffer;
offset = copy_src->offset;
size = copy_src->size;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageMemoryBarrier2KHR::safe_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR* in_struct) :
sType(in_struct->sType),
srcStageMask(in_struct->srcStageMask),
srcAccessMask(in_struct->srcAccessMask),
dstStageMask(in_struct->dstStageMask),
dstAccessMask(in_struct->dstAccessMask),
oldLayout(in_struct->oldLayout),
newLayout(in_struct->newLayout),
srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
image(in_struct->image),
subresourceRange(in_struct->subresourceRange)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageMemoryBarrier2KHR::safe_VkImageMemoryBarrier2KHR() :
sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR),
pNext(nullptr)
{}
safe_VkImageMemoryBarrier2KHR::safe_VkImageMemoryBarrier2KHR(const safe_VkImageMemoryBarrier2KHR& copy_src)
{
sType = copy_src.sType;
srcStageMask = copy_src.srcStageMask;
srcAccessMask = copy_src.srcAccessMask;
dstStageMask = copy_src.dstStageMask;
dstAccessMask = copy_src.dstAccessMask;
oldLayout = copy_src.oldLayout;
newLayout = copy_src.newLayout;
srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
image = copy_src.image;
subresourceRange = copy_src.subresourceRange;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageMemoryBarrier2KHR& safe_VkImageMemoryBarrier2KHR::operator=(const safe_VkImageMemoryBarrier2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcStageMask = copy_src.srcStageMask;
srcAccessMask = copy_src.srcAccessMask;
dstStageMask = copy_src.dstStageMask;
dstAccessMask = copy_src.dstAccessMask;
oldLayout = copy_src.oldLayout;
newLayout = copy_src.newLayout;
srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
image = copy_src.image;
subresourceRange = copy_src.subresourceRange;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageMemoryBarrier2KHR::~safe_VkImageMemoryBarrier2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageMemoryBarrier2KHR::initialize(const VkImageMemoryBarrier2KHR* in_struct)
{
sType = in_struct->sType;
srcStageMask = in_struct->srcStageMask;
srcAccessMask = in_struct->srcAccessMask;
dstStageMask = in_struct->dstStageMask;
dstAccessMask = in_struct->dstAccessMask;
oldLayout = in_struct->oldLayout;
newLayout = in_struct->newLayout;
srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
image = in_struct->image;
subresourceRange = in_struct->subresourceRange;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageMemoryBarrier2KHR::initialize(const safe_VkImageMemoryBarrier2KHR* copy_src)
{
sType = copy_src->sType;
srcStageMask = copy_src->srcStageMask;
srcAccessMask = copy_src->srcAccessMask;
dstStageMask = copy_src->dstStageMask;
dstAccessMask = copy_src->dstAccessMask;
oldLayout = copy_src->oldLayout;
newLayout = copy_src->newLayout;
srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
image = copy_src->image;
subresourceRange = copy_src->subresourceRange;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDependencyInfoKHR::safe_VkDependencyInfoKHR(const VkDependencyInfoKHR* in_struct) :
sType(in_struct->sType),
dependencyFlags(in_struct->dependencyFlags),
memoryBarrierCount(in_struct->memoryBarrierCount),
pMemoryBarriers(nullptr),
bufferMemoryBarrierCount(in_struct->bufferMemoryBarrierCount),
pBufferMemoryBarriers(nullptr),
imageMemoryBarrierCount(in_struct->imageMemoryBarrierCount),
pImageMemoryBarriers(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (memoryBarrierCount && in_struct->pMemoryBarriers) {
pMemoryBarriers = new safe_VkMemoryBarrier2KHR[memoryBarrierCount];
for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
pMemoryBarriers[i].initialize(&in_struct->pMemoryBarriers[i]);
}
}
if (bufferMemoryBarrierCount && in_struct->pBufferMemoryBarriers) {
pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2KHR[bufferMemoryBarrierCount];
for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
pBufferMemoryBarriers[i].initialize(&in_struct->pBufferMemoryBarriers[i]);
}
}
if (imageMemoryBarrierCount && in_struct->pImageMemoryBarriers) {
pImageMemoryBarriers = new safe_VkImageMemoryBarrier2KHR[imageMemoryBarrierCount];
for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
pImageMemoryBarriers[i].initialize(&in_struct->pImageMemoryBarriers[i]);
}
}
}
safe_VkDependencyInfoKHR::safe_VkDependencyInfoKHR() :
sType(VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR),
pNext(nullptr),
pMemoryBarriers(nullptr),
pBufferMemoryBarriers(nullptr),
pImageMemoryBarriers(nullptr)
{}
safe_VkDependencyInfoKHR::safe_VkDependencyInfoKHR(const safe_VkDependencyInfoKHR& copy_src)
{
sType = copy_src.sType;
dependencyFlags = copy_src.dependencyFlags;
memoryBarrierCount = copy_src.memoryBarrierCount;
pMemoryBarriers = nullptr;
bufferMemoryBarrierCount = copy_src.bufferMemoryBarrierCount;
pBufferMemoryBarriers = nullptr;
imageMemoryBarrierCount = copy_src.imageMemoryBarrierCount;
pImageMemoryBarriers = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (memoryBarrierCount && copy_src.pMemoryBarriers) {
pMemoryBarriers = new safe_VkMemoryBarrier2KHR[memoryBarrierCount];
for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
pMemoryBarriers[i].initialize(&copy_src.pMemoryBarriers[i]);
}
}
if (bufferMemoryBarrierCount && copy_src.pBufferMemoryBarriers) {
pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2KHR[bufferMemoryBarrierCount];
for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
pBufferMemoryBarriers[i].initialize(&copy_src.pBufferMemoryBarriers[i]);
}
}
if (imageMemoryBarrierCount && copy_src.pImageMemoryBarriers) {
pImageMemoryBarriers = new safe_VkImageMemoryBarrier2KHR[imageMemoryBarrierCount];
for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
pImageMemoryBarriers[i].initialize(&copy_src.pImageMemoryBarriers[i]);
}
}
}
safe_VkDependencyInfoKHR& safe_VkDependencyInfoKHR::operator=(const safe_VkDependencyInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pMemoryBarriers)
delete[] pMemoryBarriers;
if (pBufferMemoryBarriers)
delete[] pBufferMemoryBarriers;
if (pImageMemoryBarriers)
delete[] pImageMemoryBarriers;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
dependencyFlags = copy_src.dependencyFlags;
memoryBarrierCount = copy_src.memoryBarrierCount;
pMemoryBarriers = nullptr;
bufferMemoryBarrierCount = copy_src.bufferMemoryBarrierCount;
pBufferMemoryBarriers = nullptr;
imageMemoryBarrierCount = copy_src.imageMemoryBarrierCount;
pImageMemoryBarriers = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (memoryBarrierCount && copy_src.pMemoryBarriers) {
pMemoryBarriers = new safe_VkMemoryBarrier2KHR[memoryBarrierCount];
for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
pMemoryBarriers[i].initialize(&copy_src.pMemoryBarriers[i]);
}
}
if (bufferMemoryBarrierCount && copy_src.pBufferMemoryBarriers) {
pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2KHR[bufferMemoryBarrierCount];
for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
pBufferMemoryBarriers[i].initialize(&copy_src.pBufferMemoryBarriers[i]);
}
}
if (imageMemoryBarrierCount && copy_src.pImageMemoryBarriers) {
pImageMemoryBarriers = new safe_VkImageMemoryBarrier2KHR[imageMemoryBarrierCount];
for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
pImageMemoryBarriers[i].initialize(&copy_src.pImageMemoryBarriers[i]);
}
}
return *this;
}
safe_VkDependencyInfoKHR::~safe_VkDependencyInfoKHR()
{
if (pMemoryBarriers)
delete[] pMemoryBarriers;
if (pBufferMemoryBarriers)
delete[] pBufferMemoryBarriers;
if (pImageMemoryBarriers)
delete[] pImageMemoryBarriers;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDependencyInfoKHR::initialize(const VkDependencyInfoKHR* in_struct)
{
sType = in_struct->sType;
dependencyFlags = in_struct->dependencyFlags;
memoryBarrierCount = in_struct->memoryBarrierCount;
pMemoryBarriers = nullptr;
bufferMemoryBarrierCount = in_struct->bufferMemoryBarrierCount;
pBufferMemoryBarriers = nullptr;
imageMemoryBarrierCount = in_struct->imageMemoryBarrierCount;
pImageMemoryBarriers = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (memoryBarrierCount && in_struct->pMemoryBarriers) {
pMemoryBarriers = new safe_VkMemoryBarrier2KHR[memoryBarrierCount];
for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
pMemoryBarriers[i].initialize(&in_struct->pMemoryBarriers[i]);
}
}
if (bufferMemoryBarrierCount && in_struct->pBufferMemoryBarriers) {
pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2KHR[bufferMemoryBarrierCount];
for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
pBufferMemoryBarriers[i].initialize(&in_struct->pBufferMemoryBarriers[i]);
}
}
if (imageMemoryBarrierCount && in_struct->pImageMemoryBarriers) {
pImageMemoryBarriers = new safe_VkImageMemoryBarrier2KHR[imageMemoryBarrierCount];
for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
pImageMemoryBarriers[i].initialize(&in_struct->pImageMemoryBarriers[i]);
}
}
}
void safe_VkDependencyInfoKHR::initialize(const safe_VkDependencyInfoKHR* copy_src)
{
sType = copy_src->sType;
dependencyFlags = copy_src->dependencyFlags;
memoryBarrierCount = copy_src->memoryBarrierCount;
pMemoryBarriers = nullptr;
bufferMemoryBarrierCount = copy_src->bufferMemoryBarrierCount;
pBufferMemoryBarriers = nullptr;
imageMemoryBarrierCount = copy_src->imageMemoryBarrierCount;
pImageMemoryBarriers = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (memoryBarrierCount && copy_src->pMemoryBarriers) {
pMemoryBarriers = new safe_VkMemoryBarrier2KHR[memoryBarrierCount];
for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
pMemoryBarriers[i].initialize(&copy_src->pMemoryBarriers[i]);
}
}
if (bufferMemoryBarrierCount && copy_src->pBufferMemoryBarriers) {
pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2KHR[bufferMemoryBarrierCount];
for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
pBufferMemoryBarriers[i].initialize(&copy_src->pBufferMemoryBarriers[i]);
}
}
if (imageMemoryBarrierCount && copy_src->pImageMemoryBarriers) {
pImageMemoryBarriers = new safe_VkImageMemoryBarrier2KHR[imageMemoryBarrierCount];
for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
pImageMemoryBarriers[i].initialize(&copy_src->pImageMemoryBarriers[i]);
}
}
}
safe_VkSemaphoreSubmitInfoKHR::safe_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR* in_struct) :
sType(in_struct->sType),
semaphore(in_struct->semaphore),
value(in_struct->value),
stageMask(in_struct->stageMask),
deviceIndex(in_struct->deviceIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSemaphoreSubmitInfoKHR::safe_VkSemaphoreSubmitInfoKHR() :
sType(VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR),
pNext(nullptr)
{}
safe_VkSemaphoreSubmitInfoKHR::safe_VkSemaphoreSubmitInfoKHR(const safe_VkSemaphoreSubmitInfoKHR& copy_src)
{
sType = copy_src.sType;
semaphore = copy_src.semaphore;
value = copy_src.value;
stageMask = copy_src.stageMask;
deviceIndex = copy_src.deviceIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSemaphoreSubmitInfoKHR& safe_VkSemaphoreSubmitInfoKHR::operator=(const safe_VkSemaphoreSubmitInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphore = copy_src.semaphore;
value = copy_src.value;
stageMask = copy_src.stageMask;
deviceIndex = copy_src.deviceIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSemaphoreSubmitInfoKHR::~safe_VkSemaphoreSubmitInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSemaphoreSubmitInfoKHR::initialize(const VkSemaphoreSubmitInfoKHR* in_struct)
{
sType = in_struct->sType;
semaphore = in_struct->semaphore;
value = in_struct->value;
stageMask = in_struct->stageMask;
deviceIndex = in_struct->deviceIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSemaphoreSubmitInfoKHR::initialize(const safe_VkSemaphoreSubmitInfoKHR* copy_src)
{
sType = copy_src->sType;
semaphore = copy_src->semaphore;
value = copy_src->value;
stageMask = copy_src->stageMask;
deviceIndex = copy_src->deviceIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCommandBufferSubmitInfoKHR::safe_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR* in_struct) :
sType(in_struct->sType),
commandBuffer(in_struct->commandBuffer),
deviceMask(in_struct->deviceMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCommandBufferSubmitInfoKHR::safe_VkCommandBufferSubmitInfoKHR() :
sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR),
pNext(nullptr)
{}
safe_VkCommandBufferSubmitInfoKHR::safe_VkCommandBufferSubmitInfoKHR(const safe_VkCommandBufferSubmitInfoKHR& copy_src)
{
sType = copy_src.sType;
commandBuffer = copy_src.commandBuffer;
deviceMask = copy_src.deviceMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCommandBufferSubmitInfoKHR& safe_VkCommandBufferSubmitInfoKHR::operator=(const safe_VkCommandBufferSubmitInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
commandBuffer = copy_src.commandBuffer;
deviceMask = copy_src.deviceMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCommandBufferSubmitInfoKHR::~safe_VkCommandBufferSubmitInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCommandBufferSubmitInfoKHR::initialize(const VkCommandBufferSubmitInfoKHR* in_struct)
{
sType = in_struct->sType;
commandBuffer = in_struct->commandBuffer;
deviceMask = in_struct->deviceMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCommandBufferSubmitInfoKHR::initialize(const safe_VkCommandBufferSubmitInfoKHR* copy_src)
{
sType = copy_src->sType;
commandBuffer = copy_src->commandBuffer;
deviceMask = copy_src->deviceMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSubmitInfo2KHR::safe_VkSubmitInfo2KHR(const VkSubmitInfo2KHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
waitSemaphoreInfoCount(in_struct->waitSemaphoreInfoCount),
pWaitSemaphoreInfos(nullptr),
commandBufferInfoCount(in_struct->commandBufferInfoCount),
pCommandBufferInfos(nullptr),
signalSemaphoreInfoCount(in_struct->signalSemaphoreInfoCount),
pSignalSemaphoreInfos(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (waitSemaphoreInfoCount && in_struct->pWaitSemaphoreInfos) {
pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[waitSemaphoreInfoCount];
for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
pWaitSemaphoreInfos[i].initialize(&in_struct->pWaitSemaphoreInfos[i]);
}
}
if (commandBufferInfoCount && in_struct->pCommandBufferInfos) {
pCommandBufferInfos = new safe_VkCommandBufferSubmitInfoKHR[commandBufferInfoCount];
for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
pCommandBufferInfos[i].initialize(&in_struct->pCommandBufferInfos[i]);
}
}
if (signalSemaphoreInfoCount && in_struct->pSignalSemaphoreInfos) {
pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[signalSemaphoreInfoCount];
for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
pSignalSemaphoreInfos[i].initialize(&in_struct->pSignalSemaphoreInfos[i]);
}
}
}
safe_VkSubmitInfo2KHR::safe_VkSubmitInfo2KHR() :
sType(VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR),
pNext(nullptr),
pWaitSemaphoreInfos(nullptr),
pCommandBufferInfos(nullptr),
pSignalSemaphoreInfos(nullptr)
{}
safe_VkSubmitInfo2KHR::safe_VkSubmitInfo2KHR(const safe_VkSubmitInfo2KHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
waitSemaphoreInfoCount = copy_src.waitSemaphoreInfoCount;
pWaitSemaphoreInfos = nullptr;
commandBufferInfoCount = copy_src.commandBufferInfoCount;
pCommandBufferInfos = nullptr;
signalSemaphoreInfoCount = copy_src.signalSemaphoreInfoCount;
pSignalSemaphoreInfos = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (waitSemaphoreInfoCount && copy_src.pWaitSemaphoreInfos) {
pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[waitSemaphoreInfoCount];
for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
pWaitSemaphoreInfos[i].initialize(&copy_src.pWaitSemaphoreInfos[i]);
}
}
if (commandBufferInfoCount && copy_src.pCommandBufferInfos) {
pCommandBufferInfos = new safe_VkCommandBufferSubmitInfoKHR[commandBufferInfoCount];
for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
pCommandBufferInfos[i].initialize(&copy_src.pCommandBufferInfos[i]);
}
}
if (signalSemaphoreInfoCount && copy_src.pSignalSemaphoreInfos) {
pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[signalSemaphoreInfoCount];
for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
pSignalSemaphoreInfos[i].initialize(&copy_src.pSignalSemaphoreInfos[i]);
}
}
}
safe_VkSubmitInfo2KHR& safe_VkSubmitInfo2KHR::operator=(const safe_VkSubmitInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pWaitSemaphoreInfos)
delete[] pWaitSemaphoreInfos;
if (pCommandBufferInfos)
delete[] pCommandBufferInfos;
if (pSignalSemaphoreInfos)
delete[] pSignalSemaphoreInfos;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
waitSemaphoreInfoCount = copy_src.waitSemaphoreInfoCount;
pWaitSemaphoreInfos = nullptr;
commandBufferInfoCount = copy_src.commandBufferInfoCount;
pCommandBufferInfos = nullptr;
signalSemaphoreInfoCount = copy_src.signalSemaphoreInfoCount;
pSignalSemaphoreInfos = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (waitSemaphoreInfoCount && copy_src.pWaitSemaphoreInfos) {
pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[waitSemaphoreInfoCount];
for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
pWaitSemaphoreInfos[i].initialize(&copy_src.pWaitSemaphoreInfos[i]);
}
}
if (commandBufferInfoCount && copy_src.pCommandBufferInfos) {
pCommandBufferInfos = new safe_VkCommandBufferSubmitInfoKHR[commandBufferInfoCount];
for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
pCommandBufferInfos[i].initialize(&copy_src.pCommandBufferInfos[i]);
}
}
if (signalSemaphoreInfoCount && copy_src.pSignalSemaphoreInfos) {
pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[signalSemaphoreInfoCount];
for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
pSignalSemaphoreInfos[i].initialize(&copy_src.pSignalSemaphoreInfos[i]);
}
}
return *this;
}
safe_VkSubmitInfo2KHR::~safe_VkSubmitInfo2KHR()
{
if (pWaitSemaphoreInfos)
delete[] pWaitSemaphoreInfos;
if (pCommandBufferInfos)
delete[] pCommandBufferInfos;
if (pSignalSemaphoreInfos)
delete[] pSignalSemaphoreInfos;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSubmitInfo2KHR::initialize(const VkSubmitInfo2KHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
waitSemaphoreInfoCount = in_struct->waitSemaphoreInfoCount;
pWaitSemaphoreInfos = nullptr;
commandBufferInfoCount = in_struct->commandBufferInfoCount;
pCommandBufferInfos = nullptr;
signalSemaphoreInfoCount = in_struct->signalSemaphoreInfoCount;
pSignalSemaphoreInfos = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (waitSemaphoreInfoCount && in_struct->pWaitSemaphoreInfos) {
pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[waitSemaphoreInfoCount];
for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
pWaitSemaphoreInfos[i].initialize(&in_struct->pWaitSemaphoreInfos[i]);
}
}
if (commandBufferInfoCount && in_struct->pCommandBufferInfos) {
pCommandBufferInfos = new safe_VkCommandBufferSubmitInfoKHR[commandBufferInfoCount];
for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
pCommandBufferInfos[i].initialize(&in_struct->pCommandBufferInfos[i]);
}
}
if (signalSemaphoreInfoCount && in_struct->pSignalSemaphoreInfos) {
pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[signalSemaphoreInfoCount];
for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
pSignalSemaphoreInfos[i].initialize(&in_struct->pSignalSemaphoreInfos[i]);
}
}
}
void safe_VkSubmitInfo2KHR::initialize(const safe_VkSubmitInfo2KHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
waitSemaphoreInfoCount = copy_src->waitSemaphoreInfoCount;
pWaitSemaphoreInfos = nullptr;
commandBufferInfoCount = copy_src->commandBufferInfoCount;
pCommandBufferInfos = nullptr;
signalSemaphoreInfoCount = copy_src->signalSemaphoreInfoCount;
pSignalSemaphoreInfos = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (waitSemaphoreInfoCount && copy_src->pWaitSemaphoreInfos) {
pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[waitSemaphoreInfoCount];
for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
pWaitSemaphoreInfos[i].initialize(&copy_src->pWaitSemaphoreInfos[i]);
}
}
if (commandBufferInfoCount && copy_src->pCommandBufferInfos) {
pCommandBufferInfos = new safe_VkCommandBufferSubmitInfoKHR[commandBufferInfoCount];
for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
pCommandBufferInfos[i].initialize(&copy_src->pCommandBufferInfos[i]);
}
}
if (signalSemaphoreInfoCount && copy_src->pSignalSemaphoreInfos) {
pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfoKHR[signalSemaphoreInfoCount];
for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
pSignalSemaphoreInfos[i].initialize(&copy_src->pSignalSemaphoreInfos[i]);
}
}
}
safe_VkPhysicalDeviceSynchronization2FeaturesKHR::safe_VkPhysicalDeviceSynchronization2FeaturesKHR(const VkPhysicalDeviceSynchronization2FeaturesKHR* in_struct) :
sType(in_struct->sType),
synchronization2(in_struct->synchronization2)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSynchronization2FeaturesKHR::safe_VkPhysicalDeviceSynchronization2FeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSynchronization2FeaturesKHR::safe_VkPhysicalDeviceSynchronization2FeaturesKHR(const safe_VkPhysicalDeviceSynchronization2FeaturesKHR& copy_src)
{
sType = copy_src.sType;
synchronization2 = copy_src.synchronization2;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSynchronization2FeaturesKHR& safe_VkPhysicalDeviceSynchronization2FeaturesKHR::operator=(const safe_VkPhysicalDeviceSynchronization2FeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
synchronization2 = copy_src.synchronization2;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSynchronization2FeaturesKHR::~safe_VkPhysicalDeviceSynchronization2FeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSynchronization2FeaturesKHR::initialize(const VkPhysicalDeviceSynchronization2FeaturesKHR* in_struct)
{
sType = in_struct->sType;
synchronization2 = in_struct->synchronization2;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSynchronization2FeaturesKHR::initialize(const safe_VkPhysicalDeviceSynchronization2FeaturesKHR* copy_src)
{
sType = copy_src->sType;
synchronization2 = copy_src->synchronization2;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* in_struct) :
sType(in_struct->sType),
checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV() :
sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV),
pNext(nullptr)
{}
safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src)
{
sType = copy_src.sType;
checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkQueueFamilyCheckpointProperties2NV& safe_VkQueueFamilyCheckpointProperties2NV::operator=(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkQueueFamilyCheckpointProperties2NV::~safe_VkQueueFamilyCheckpointProperties2NV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct)
{
sType = in_struct->sType;
checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src)
{
sType = copy_src->sType;
checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct) :
sType(in_struct->sType),
stage(in_struct->stage),
pCheckpointMarker(in_struct->pCheckpointMarker)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCheckpointData2NV::safe_VkCheckpointData2NV() :
sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV),
pNext(nullptr),
pCheckpointMarker(nullptr)
{}
safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src)
{
sType = copy_src.sType;
stage = copy_src.stage;
pCheckpointMarker = copy_src.pCheckpointMarker;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCheckpointData2NV& safe_VkCheckpointData2NV::operator=(const safe_VkCheckpointData2NV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stage = copy_src.stage;
pCheckpointMarker = copy_src.pCheckpointMarker;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCheckpointData2NV::~safe_VkCheckpointData2NV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCheckpointData2NV::initialize(const VkCheckpointData2NV* in_struct)
{
sType = in_struct->sType;
stage = in_struct->stage;
pCheckpointMarker = in_struct->pCheckpointMarker;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCheckpointData2NV::initialize(const safe_VkCheckpointData2NV* copy_src)
{
sType = copy_src->sType;
stage = copy_src->stage;
pCheckpointMarker = copy_src->pCheckpointMarker;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* in_struct) :
sType(in_struct->sType),
shaderZeroInitializeWorkgroupMemory(in_struct->shaderZeroInitializeWorkgroupMemory)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR& copy_src)
{
sType = copy_src.sType;
shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR& safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::operator=(const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::~safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::initialize(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* in_struct)
{
sType = in_struct->sType;
shaderZeroInitializeWorkgroupMemory = in_struct->shaderZeroInitializeWorkgroupMemory;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::initialize(const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* copy_src)
{
sType = copy_src->sType;
shaderZeroInitializeWorkgroupMemory = copy_src->shaderZeroInitializeWorkgroupMemory;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct) :
sType(in_struct->sType),
workgroupMemoryExplicitLayout(in_struct->workgroupMemoryExplicitLayout),
workgroupMemoryExplicitLayoutScalarBlockLayout(in_struct->workgroupMemoryExplicitLayoutScalarBlockLayout),
workgroupMemoryExplicitLayout8BitAccess(in_struct->workgroupMemoryExplicitLayout8BitAccess),
workgroupMemoryExplicitLayout16BitAccess(in_struct->workgroupMemoryExplicitLayout16BitAccess)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src)
{
sType = copy_src.sType;
workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout;
workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout;
workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess;
workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::operator=(const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout;
workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout;
workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess;
workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct)
{
sType = in_struct->sType;
workgroupMemoryExplicitLayout = in_struct->workgroupMemoryExplicitLayout;
workgroupMemoryExplicitLayoutScalarBlockLayout = in_struct->workgroupMemoryExplicitLayoutScalarBlockLayout;
workgroupMemoryExplicitLayout8BitAccess = in_struct->workgroupMemoryExplicitLayout8BitAccess;
workgroupMemoryExplicitLayout16BitAccess = in_struct->workgroupMemoryExplicitLayout16BitAccess;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize(const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src)
{
sType = copy_src->sType;
workgroupMemoryExplicitLayout = copy_src->workgroupMemoryExplicitLayout;
workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src->workgroupMemoryExplicitLayoutScalarBlockLayout;
workgroupMemoryExplicitLayout8BitAccess = copy_src->workgroupMemoryExplicitLayout8BitAccess;
workgroupMemoryExplicitLayout16BitAccess = copy_src->workgroupMemoryExplicitLayout16BitAccess;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBufferCopy2KHR::safe_VkBufferCopy2KHR(const VkBufferCopy2KHR* in_struct) :
sType(in_struct->sType),
srcOffset(in_struct->srcOffset),
dstOffset(in_struct->dstOffset),
size(in_struct->size)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferCopy2KHR::safe_VkBufferCopy2KHR() :
sType(VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR),
pNext(nullptr)
{}
safe_VkBufferCopy2KHR::safe_VkBufferCopy2KHR(const safe_VkBufferCopy2KHR& copy_src)
{
sType = copy_src.sType;
srcOffset = copy_src.srcOffset;
dstOffset = copy_src.dstOffset;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferCopy2KHR& safe_VkBufferCopy2KHR::operator=(const safe_VkBufferCopy2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcOffset = copy_src.srcOffset;
dstOffset = copy_src.dstOffset;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferCopy2KHR::~safe_VkBufferCopy2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferCopy2KHR::initialize(const VkBufferCopy2KHR* in_struct)
{
sType = in_struct->sType;
srcOffset = in_struct->srcOffset;
dstOffset = in_struct->dstOffset;
size = in_struct->size;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferCopy2KHR::initialize(const safe_VkBufferCopy2KHR* copy_src)
{
sType = copy_src->sType;
srcOffset = copy_src->srcOffset;
dstOffset = copy_src->dstOffset;
size = copy_src->size;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCopyBufferInfo2KHR::safe_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR* in_struct) :
sType(in_struct->sType),
srcBuffer(in_struct->srcBuffer),
dstBuffer(in_struct->dstBuffer),
regionCount(in_struct->regionCount),
pRegions(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkBufferCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
safe_VkCopyBufferInfo2KHR::safe_VkCopyBufferInfo2KHR() :
sType(VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR),
pNext(nullptr),
pRegions(nullptr)
{}
safe_VkCopyBufferInfo2KHR::safe_VkCopyBufferInfo2KHR(const safe_VkCopyBufferInfo2KHR& copy_src)
{
sType = copy_src.sType;
srcBuffer = copy_src.srcBuffer;
dstBuffer = copy_src.dstBuffer;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkBufferCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
}
safe_VkCopyBufferInfo2KHR& safe_VkCopyBufferInfo2KHR::operator=(const safe_VkCopyBufferInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcBuffer = copy_src.srcBuffer;
dstBuffer = copy_src.dstBuffer;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkBufferCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
return *this;
}
safe_VkCopyBufferInfo2KHR::~safe_VkCopyBufferInfo2KHR()
{
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyBufferInfo2KHR::initialize(const VkCopyBufferInfo2KHR* in_struct)
{
sType = in_struct->sType;
srcBuffer = in_struct->srcBuffer;
dstBuffer = in_struct->dstBuffer;
regionCount = in_struct->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkBufferCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
void safe_VkCopyBufferInfo2KHR::initialize(const safe_VkCopyBufferInfo2KHR* copy_src)
{
sType = copy_src->sType;
srcBuffer = copy_src->srcBuffer;
dstBuffer = copy_src->dstBuffer;
regionCount = copy_src->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (regionCount && copy_src->pRegions) {
pRegions = new safe_VkBufferCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src->pRegions[i]);
}
}
}
safe_VkImageCopy2KHR::safe_VkImageCopy2KHR(const VkImageCopy2KHR* in_struct) :
sType(in_struct->sType),
srcSubresource(in_struct->srcSubresource),
srcOffset(in_struct->srcOffset),
dstSubresource(in_struct->dstSubresource),
dstOffset(in_struct->dstOffset),
extent(in_struct->extent)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageCopy2KHR::safe_VkImageCopy2KHR() :
sType(VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR),
pNext(nullptr)
{}
safe_VkImageCopy2KHR::safe_VkImageCopy2KHR(const safe_VkImageCopy2KHR& copy_src)
{
sType = copy_src.sType;
srcSubresource = copy_src.srcSubresource;
srcOffset = copy_src.srcOffset;
dstSubresource = copy_src.dstSubresource;
dstOffset = copy_src.dstOffset;
extent = copy_src.extent;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageCopy2KHR& safe_VkImageCopy2KHR::operator=(const safe_VkImageCopy2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcSubresource = copy_src.srcSubresource;
srcOffset = copy_src.srcOffset;
dstSubresource = copy_src.dstSubresource;
dstOffset = copy_src.dstOffset;
extent = copy_src.extent;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageCopy2KHR::~safe_VkImageCopy2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageCopy2KHR::initialize(const VkImageCopy2KHR* in_struct)
{
sType = in_struct->sType;
srcSubresource = in_struct->srcSubresource;
srcOffset = in_struct->srcOffset;
dstSubresource = in_struct->dstSubresource;
dstOffset = in_struct->dstOffset;
extent = in_struct->extent;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageCopy2KHR::initialize(const safe_VkImageCopy2KHR* copy_src)
{
sType = copy_src->sType;
srcSubresource = copy_src->srcSubresource;
srcOffset = copy_src->srcOffset;
dstSubresource = copy_src->dstSubresource;
dstOffset = copy_src->dstOffset;
extent = copy_src->extent;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCopyImageInfo2KHR::safe_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR* in_struct) :
sType(in_struct->sType),
srcImage(in_struct->srcImage),
srcImageLayout(in_struct->srcImageLayout),
dstImage(in_struct->dstImage),
dstImageLayout(in_struct->dstImageLayout),
regionCount(in_struct->regionCount),
pRegions(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
safe_VkCopyImageInfo2KHR::safe_VkCopyImageInfo2KHR() :
sType(VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR),
pNext(nullptr),
pRegions(nullptr)
{}
safe_VkCopyImageInfo2KHR::safe_VkCopyImageInfo2KHR(const safe_VkCopyImageInfo2KHR& copy_src)
{
sType = copy_src.sType;
srcImage = copy_src.srcImage;
srcImageLayout = copy_src.srcImageLayout;
dstImage = copy_src.dstImage;
dstImageLayout = copy_src.dstImageLayout;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
}
safe_VkCopyImageInfo2KHR& safe_VkCopyImageInfo2KHR::operator=(const safe_VkCopyImageInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcImage = copy_src.srcImage;
srcImageLayout = copy_src.srcImageLayout;
dstImage = copy_src.dstImage;
dstImageLayout = copy_src.dstImageLayout;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
return *this;
}
safe_VkCopyImageInfo2KHR::~safe_VkCopyImageInfo2KHR()
{
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyImageInfo2KHR::initialize(const VkCopyImageInfo2KHR* in_struct)
{
sType = in_struct->sType;
srcImage = in_struct->srcImage;
srcImageLayout = in_struct->srcImageLayout;
dstImage = in_struct->dstImage;
dstImageLayout = in_struct->dstImageLayout;
regionCount = in_struct->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
void safe_VkCopyImageInfo2KHR::initialize(const safe_VkCopyImageInfo2KHR* copy_src)
{
sType = copy_src->sType;
srcImage = copy_src->srcImage;
srcImageLayout = copy_src->srcImageLayout;
dstImage = copy_src->dstImage;
dstImageLayout = copy_src->dstImageLayout;
regionCount = copy_src->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (regionCount && copy_src->pRegions) {
pRegions = new safe_VkImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src->pRegions[i]);
}
}
}
safe_VkBufferImageCopy2KHR::safe_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR* in_struct) :
sType(in_struct->sType),
bufferOffset(in_struct->bufferOffset),
bufferRowLength(in_struct->bufferRowLength),
bufferImageHeight(in_struct->bufferImageHeight),
imageSubresource(in_struct->imageSubresource),
imageOffset(in_struct->imageOffset),
imageExtent(in_struct->imageExtent)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferImageCopy2KHR::safe_VkBufferImageCopy2KHR() :
sType(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR),
pNext(nullptr)
{}
safe_VkBufferImageCopy2KHR::safe_VkBufferImageCopy2KHR(const safe_VkBufferImageCopy2KHR& copy_src)
{
sType = copy_src.sType;
bufferOffset = copy_src.bufferOffset;
bufferRowLength = copy_src.bufferRowLength;
bufferImageHeight = copy_src.bufferImageHeight;
imageSubresource = copy_src.imageSubresource;
imageOffset = copy_src.imageOffset;
imageExtent = copy_src.imageExtent;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferImageCopy2KHR& safe_VkBufferImageCopy2KHR::operator=(const safe_VkBufferImageCopy2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
bufferOffset = copy_src.bufferOffset;
bufferRowLength = copy_src.bufferRowLength;
bufferImageHeight = copy_src.bufferImageHeight;
imageSubresource = copy_src.imageSubresource;
imageOffset = copy_src.imageOffset;
imageExtent = copy_src.imageExtent;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferImageCopy2KHR::~safe_VkBufferImageCopy2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferImageCopy2KHR::initialize(const VkBufferImageCopy2KHR* in_struct)
{
sType = in_struct->sType;
bufferOffset = in_struct->bufferOffset;
bufferRowLength = in_struct->bufferRowLength;
bufferImageHeight = in_struct->bufferImageHeight;
imageSubresource = in_struct->imageSubresource;
imageOffset = in_struct->imageOffset;
imageExtent = in_struct->imageExtent;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferImageCopy2KHR::initialize(const safe_VkBufferImageCopy2KHR* copy_src)
{
sType = copy_src->sType;
bufferOffset = copy_src->bufferOffset;
bufferRowLength = copy_src->bufferRowLength;
bufferImageHeight = copy_src->bufferImageHeight;
imageSubresource = copy_src->imageSubresource;
imageOffset = copy_src->imageOffset;
imageExtent = copy_src->imageExtent;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCopyBufferToImageInfo2KHR::safe_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR* in_struct) :
sType(in_struct->sType),
srcBuffer(in_struct->srcBuffer),
dstImage(in_struct->dstImage),
dstImageLayout(in_struct->dstImageLayout),
regionCount(in_struct->regionCount),
pRegions(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
safe_VkCopyBufferToImageInfo2KHR::safe_VkCopyBufferToImageInfo2KHR() :
sType(VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR),
pNext(nullptr),
pRegions(nullptr)
{}
safe_VkCopyBufferToImageInfo2KHR::safe_VkCopyBufferToImageInfo2KHR(const safe_VkCopyBufferToImageInfo2KHR& copy_src)
{
sType = copy_src.sType;
srcBuffer = copy_src.srcBuffer;
dstImage = copy_src.dstImage;
dstImageLayout = copy_src.dstImageLayout;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
}
safe_VkCopyBufferToImageInfo2KHR& safe_VkCopyBufferToImageInfo2KHR::operator=(const safe_VkCopyBufferToImageInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcBuffer = copy_src.srcBuffer;
dstImage = copy_src.dstImage;
dstImageLayout = copy_src.dstImageLayout;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
return *this;
}
safe_VkCopyBufferToImageInfo2KHR::~safe_VkCopyBufferToImageInfo2KHR()
{
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyBufferToImageInfo2KHR::initialize(const VkCopyBufferToImageInfo2KHR* in_struct)
{
sType = in_struct->sType;
srcBuffer = in_struct->srcBuffer;
dstImage = in_struct->dstImage;
dstImageLayout = in_struct->dstImageLayout;
regionCount = in_struct->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
void safe_VkCopyBufferToImageInfo2KHR::initialize(const safe_VkCopyBufferToImageInfo2KHR* copy_src)
{
sType = copy_src->sType;
srcBuffer = copy_src->srcBuffer;
dstImage = copy_src->dstImage;
dstImageLayout = copy_src->dstImageLayout;
regionCount = copy_src->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (regionCount && copy_src->pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src->pRegions[i]);
}
}
}
safe_VkCopyImageToBufferInfo2KHR::safe_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR* in_struct) :
sType(in_struct->sType),
srcImage(in_struct->srcImage),
srcImageLayout(in_struct->srcImageLayout),
dstBuffer(in_struct->dstBuffer),
regionCount(in_struct->regionCount),
pRegions(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
safe_VkCopyImageToBufferInfo2KHR::safe_VkCopyImageToBufferInfo2KHR() :
sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR),
pNext(nullptr),
pRegions(nullptr)
{}
safe_VkCopyImageToBufferInfo2KHR::safe_VkCopyImageToBufferInfo2KHR(const safe_VkCopyImageToBufferInfo2KHR& copy_src)
{
sType = copy_src.sType;
srcImage = copy_src.srcImage;
srcImageLayout = copy_src.srcImageLayout;
dstBuffer = copy_src.dstBuffer;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
}
safe_VkCopyImageToBufferInfo2KHR& safe_VkCopyImageToBufferInfo2KHR::operator=(const safe_VkCopyImageToBufferInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcImage = copy_src.srcImage;
srcImageLayout = copy_src.srcImageLayout;
dstBuffer = copy_src.dstBuffer;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
return *this;
}
safe_VkCopyImageToBufferInfo2KHR::~safe_VkCopyImageToBufferInfo2KHR()
{
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyImageToBufferInfo2KHR::initialize(const VkCopyImageToBufferInfo2KHR* in_struct)
{
sType = in_struct->sType;
srcImage = in_struct->srcImage;
srcImageLayout = in_struct->srcImageLayout;
dstBuffer = in_struct->dstBuffer;
regionCount = in_struct->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
void safe_VkCopyImageToBufferInfo2KHR::initialize(const safe_VkCopyImageToBufferInfo2KHR* copy_src)
{
sType = copy_src->sType;
srcImage = copy_src->srcImage;
srcImageLayout = copy_src->srcImageLayout;
dstBuffer = copy_src->dstBuffer;
regionCount = copy_src->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (regionCount && copy_src->pRegions) {
pRegions = new safe_VkBufferImageCopy2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src->pRegions[i]);
}
}
}
safe_VkImageBlit2KHR::safe_VkImageBlit2KHR(const VkImageBlit2KHR* in_struct) :
sType(in_struct->sType),
srcSubresource(in_struct->srcSubresource),
dstSubresource(in_struct->dstSubresource)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 2; ++i) {
srcOffsets[i] = in_struct->srcOffsets[i];
}
for (uint32_t i = 0; i < 2; ++i) {
dstOffsets[i] = in_struct->dstOffsets[i];
}
}
safe_VkImageBlit2KHR::safe_VkImageBlit2KHR() :
sType(VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR),
pNext(nullptr)
{}
safe_VkImageBlit2KHR::safe_VkImageBlit2KHR(const safe_VkImageBlit2KHR& copy_src)
{
sType = copy_src.sType;
srcSubresource = copy_src.srcSubresource;
dstSubresource = copy_src.dstSubresource;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 2; ++i) {
srcOffsets[i] = copy_src.srcOffsets[i];
}
for (uint32_t i = 0; i < 2; ++i) {
dstOffsets[i] = copy_src.dstOffsets[i];
}
}
safe_VkImageBlit2KHR& safe_VkImageBlit2KHR::operator=(const safe_VkImageBlit2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcSubresource = copy_src.srcSubresource;
dstSubresource = copy_src.dstSubresource;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 2; ++i) {
srcOffsets[i] = copy_src.srcOffsets[i];
}
for (uint32_t i = 0; i < 2; ++i) {
dstOffsets[i] = copy_src.dstOffsets[i];
}
return *this;
}
safe_VkImageBlit2KHR::~safe_VkImageBlit2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageBlit2KHR::initialize(const VkImageBlit2KHR* in_struct)
{
sType = in_struct->sType;
srcSubresource = in_struct->srcSubresource;
dstSubresource = in_struct->dstSubresource;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 2; ++i) {
srcOffsets[i] = in_struct->srcOffsets[i];
}
for (uint32_t i = 0; i < 2; ++i) {
dstOffsets[i] = in_struct->dstOffsets[i];
}
}
void safe_VkImageBlit2KHR::initialize(const safe_VkImageBlit2KHR* copy_src)
{
sType = copy_src->sType;
srcSubresource = copy_src->srcSubresource;
dstSubresource = copy_src->dstSubresource;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < 2; ++i) {
srcOffsets[i] = copy_src->srcOffsets[i];
}
for (uint32_t i = 0; i < 2; ++i) {
dstOffsets[i] = copy_src->dstOffsets[i];
}
}
safe_VkBlitImageInfo2KHR::safe_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR* in_struct) :
sType(in_struct->sType),
srcImage(in_struct->srcImage),
srcImageLayout(in_struct->srcImageLayout),
dstImage(in_struct->dstImage),
dstImageLayout(in_struct->dstImageLayout),
regionCount(in_struct->regionCount),
pRegions(nullptr),
filter(in_struct->filter)
{
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkImageBlit2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
safe_VkBlitImageInfo2KHR::safe_VkBlitImageInfo2KHR() :
sType(VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR),
pNext(nullptr),
pRegions(nullptr)
{}
safe_VkBlitImageInfo2KHR::safe_VkBlitImageInfo2KHR(const safe_VkBlitImageInfo2KHR& copy_src)
{
sType = copy_src.sType;
srcImage = copy_src.srcImage;
srcImageLayout = copy_src.srcImageLayout;
dstImage = copy_src.dstImage;
dstImageLayout = copy_src.dstImageLayout;
regionCount = copy_src.regionCount;
pRegions = nullptr;
filter = copy_src.filter;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkImageBlit2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
}
safe_VkBlitImageInfo2KHR& safe_VkBlitImageInfo2KHR::operator=(const safe_VkBlitImageInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcImage = copy_src.srcImage;
srcImageLayout = copy_src.srcImageLayout;
dstImage = copy_src.dstImage;
dstImageLayout = copy_src.dstImageLayout;
regionCount = copy_src.regionCount;
pRegions = nullptr;
filter = copy_src.filter;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkImageBlit2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
return *this;
}
safe_VkBlitImageInfo2KHR::~safe_VkBlitImageInfo2KHR()
{
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBlitImageInfo2KHR::initialize(const VkBlitImageInfo2KHR* in_struct)
{
sType = in_struct->sType;
srcImage = in_struct->srcImage;
srcImageLayout = in_struct->srcImageLayout;
dstImage = in_struct->dstImage;
dstImageLayout = in_struct->dstImageLayout;
regionCount = in_struct->regionCount;
pRegions = nullptr;
filter = in_struct->filter;
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkImageBlit2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
void safe_VkBlitImageInfo2KHR::initialize(const safe_VkBlitImageInfo2KHR* copy_src)
{
sType = copy_src->sType;
srcImage = copy_src->srcImage;
srcImageLayout = copy_src->srcImageLayout;
dstImage = copy_src->dstImage;
dstImageLayout = copy_src->dstImageLayout;
regionCount = copy_src->regionCount;
pRegions = nullptr;
filter = copy_src->filter;
pNext = SafePnextCopy(copy_src->pNext);
if (regionCount && copy_src->pRegions) {
pRegions = new safe_VkImageBlit2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src->pRegions[i]);
}
}
}
safe_VkImageResolve2KHR::safe_VkImageResolve2KHR(const VkImageResolve2KHR* in_struct) :
sType(in_struct->sType),
srcSubresource(in_struct->srcSubresource),
srcOffset(in_struct->srcOffset),
dstSubresource(in_struct->dstSubresource),
dstOffset(in_struct->dstOffset),
extent(in_struct->extent)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageResolve2KHR::safe_VkImageResolve2KHR() :
sType(VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR),
pNext(nullptr)
{}
safe_VkImageResolve2KHR::safe_VkImageResolve2KHR(const safe_VkImageResolve2KHR& copy_src)
{
sType = copy_src.sType;
srcSubresource = copy_src.srcSubresource;
srcOffset = copy_src.srcOffset;
dstSubresource = copy_src.dstSubresource;
dstOffset = copy_src.dstOffset;
extent = copy_src.extent;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageResolve2KHR& safe_VkImageResolve2KHR::operator=(const safe_VkImageResolve2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcSubresource = copy_src.srcSubresource;
srcOffset = copy_src.srcOffset;
dstSubresource = copy_src.dstSubresource;
dstOffset = copy_src.dstOffset;
extent = copy_src.extent;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageResolve2KHR::~safe_VkImageResolve2KHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageResolve2KHR::initialize(const VkImageResolve2KHR* in_struct)
{
sType = in_struct->sType;
srcSubresource = in_struct->srcSubresource;
srcOffset = in_struct->srcOffset;
dstSubresource = in_struct->dstSubresource;
dstOffset = in_struct->dstOffset;
extent = in_struct->extent;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageResolve2KHR::initialize(const safe_VkImageResolve2KHR* copy_src)
{
sType = copy_src->sType;
srcSubresource = copy_src->srcSubresource;
srcOffset = copy_src->srcOffset;
dstSubresource = copy_src->dstSubresource;
dstOffset = copy_src->dstOffset;
extent = copy_src->extent;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkResolveImageInfo2KHR::safe_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR* in_struct) :
sType(in_struct->sType),
srcImage(in_struct->srcImage),
srcImageLayout(in_struct->srcImageLayout),
dstImage(in_struct->dstImage),
dstImageLayout(in_struct->dstImageLayout),
regionCount(in_struct->regionCount),
pRegions(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkImageResolve2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
safe_VkResolveImageInfo2KHR::safe_VkResolveImageInfo2KHR() :
sType(VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR),
pNext(nullptr),
pRegions(nullptr)
{}
safe_VkResolveImageInfo2KHR::safe_VkResolveImageInfo2KHR(const safe_VkResolveImageInfo2KHR& copy_src)
{
sType = copy_src.sType;
srcImage = copy_src.srcImage;
srcImageLayout = copy_src.srcImageLayout;
dstImage = copy_src.dstImage;
dstImageLayout = copy_src.dstImageLayout;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkImageResolve2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
}
safe_VkResolveImageInfo2KHR& safe_VkResolveImageInfo2KHR::operator=(const safe_VkResolveImageInfo2KHR& copy_src)
{
if (&copy_src == this) return *this;
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcImage = copy_src.srcImage;
srcImageLayout = copy_src.srcImageLayout;
dstImage = copy_src.dstImage;
dstImageLayout = copy_src.dstImageLayout;
regionCount = copy_src.regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (regionCount && copy_src.pRegions) {
pRegions = new safe_VkImageResolve2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src.pRegions[i]);
}
}
return *this;
}
safe_VkResolveImageInfo2KHR::~safe_VkResolveImageInfo2KHR()
{
if (pRegions)
delete[] pRegions;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkResolveImageInfo2KHR::initialize(const VkResolveImageInfo2KHR* in_struct)
{
sType = in_struct->sType;
srcImage = in_struct->srcImage;
srcImageLayout = in_struct->srcImageLayout;
dstImage = in_struct->dstImage;
dstImageLayout = in_struct->dstImageLayout;
regionCount = in_struct->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (regionCount && in_struct->pRegions) {
pRegions = new safe_VkImageResolve2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&in_struct->pRegions[i]);
}
}
}
void safe_VkResolveImageInfo2KHR::initialize(const safe_VkResolveImageInfo2KHR* copy_src)
{
sType = copy_src->sType;
srcImage = copy_src->srcImage;
srcImageLayout = copy_src->srcImageLayout;
dstImage = copy_src->dstImage;
dstImageLayout = copy_src->dstImageLayout;
regionCount = copy_src->regionCount;
pRegions = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (regionCount && copy_src->pRegions) {
pRegions = new safe_VkImageResolve2KHR[regionCount];
for (uint32_t i = 0; i < regionCount; ++i) {
pRegions[i].initialize(&copy_src->pRegions[i]);
}
}
}
safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
pfnCallback(in_struct->pfnCallback),
pUserData(in_struct->pUserData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT),
pNext(nullptr),
pUserData(nullptr)
{}
safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pfnCallback = copy_src.pfnCallback;
pUserData = copy_src.pUserData;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDebugReportCallbackCreateInfoEXT& safe_VkDebugReportCallbackCreateInfoEXT::operator=(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pfnCallback = copy_src.pfnCallback;
pUserData = copy_src.pUserData;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDebugReportCallbackCreateInfoEXT::~safe_VkDebugReportCallbackCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pfnCallback = in_struct->pfnCallback;
pUserData = in_struct->pUserData;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const safe_VkDebugReportCallbackCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pfnCallback = copy_src->pfnCallback;
pUserData = copy_src->pUserData;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct) :
sType(in_struct->sType),
rasterizationOrder(in_struct->rasterizationOrder)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD() :
sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD),
pNext(nullptr)
{}
safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src)
{
sType = copy_src.sType;
rasterizationOrder = copy_src.rasterizationOrder;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineRasterizationStateRasterizationOrderAMD& safe_VkPipelineRasterizationStateRasterizationOrderAMD::operator=(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
rasterizationOrder = copy_src.rasterizationOrder;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineRasterizationStateRasterizationOrderAMD::~safe_VkPipelineRasterizationStateRasterizationOrderAMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct)
{
sType = in_struct->sType;
rasterizationOrder = in_struct->rasterizationOrder;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* copy_src)
{
sType = copy_src->sType;
rasterizationOrder = copy_src->rasterizationOrder;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct) :
sType(in_struct->sType),
objectType(in_struct->objectType),
object(in_struct->object)
{
pNext = SafePnextCopy(in_struct->pNext);
pObjectName = SafeStringCopy(in_struct->pObjectName);
}
safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT),
pNext(nullptr),
pObjectName(nullptr)
{}
safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src)
{
sType = copy_src.sType;
objectType = copy_src.objectType;
object = copy_src.object;
pNext = SafePnextCopy(copy_src.pNext);
pObjectName = SafeStringCopy(copy_src.pObjectName);
}
safe_VkDebugMarkerObjectNameInfoEXT& safe_VkDebugMarkerObjectNameInfoEXT::operator=(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pObjectName) delete [] pObjectName;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
objectType = copy_src.objectType;
object = copy_src.object;
pNext = SafePnextCopy(copy_src.pNext);
pObjectName = SafeStringCopy(copy_src.pObjectName);
return *this;
}
safe_VkDebugMarkerObjectNameInfoEXT::~safe_VkDebugMarkerObjectNameInfoEXT()
{
if (pObjectName) delete [] pObjectName;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct)
{
sType = in_struct->sType;
objectType = in_struct->objectType;
object = in_struct->object;
pNext = SafePnextCopy(in_struct->pNext);
pObjectName = SafeStringCopy(in_struct->pObjectName);
}
void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const safe_VkDebugMarkerObjectNameInfoEXT* copy_src)
{
sType = copy_src->sType;
objectType = copy_src->objectType;
object = copy_src->object;
pNext = SafePnextCopy(copy_src->pNext);
pObjectName = SafeStringCopy(copy_src->pObjectName);
}
safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct) :
sType(in_struct->sType),
objectType(in_struct->objectType),
object(in_struct->object),
tagName(in_struct->tagName),
tagSize(in_struct->tagSize),
pTag(in_struct->pTag)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT),
pNext(nullptr),
pTag(nullptr)
{}
safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src)
{
sType = copy_src.sType;
objectType = copy_src.objectType;
object = copy_src.object;
tagName = copy_src.tagName;
tagSize = copy_src.tagSize;
pTag = copy_src.pTag;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDebugMarkerObjectTagInfoEXT& safe_VkDebugMarkerObjectTagInfoEXT::operator=(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
objectType = copy_src.objectType;
object = copy_src.object;
tagName = copy_src.tagName;
tagSize = copy_src.tagSize;
pTag = copy_src.pTag;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDebugMarkerObjectTagInfoEXT::~safe_VkDebugMarkerObjectTagInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct)
{
sType = in_struct->sType;
objectType = in_struct->objectType;
object = in_struct->object;
tagName = in_struct->tagName;
tagSize = in_struct->tagSize;
pTag = in_struct->pTag;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const safe_VkDebugMarkerObjectTagInfoEXT* copy_src)
{
sType = copy_src->sType;
objectType = copy_src->objectType;
object = copy_src->object;
tagName = copy_src->tagName;
tagSize = copy_src->tagSize;
pTag = copy_src->pTag;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct) :
sType(in_struct->sType)
{
pNext = SafePnextCopy(in_struct->pNext);
pMarkerName = SafeStringCopy(in_struct->pMarkerName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = in_struct->color[i];
}
}
safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT),
pNext(nullptr),
pMarkerName(nullptr)
{}
safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& copy_src)
{
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
pMarkerName = SafeStringCopy(copy_src.pMarkerName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = copy_src.color[i];
}
}
safe_VkDebugMarkerMarkerInfoEXT& safe_VkDebugMarkerMarkerInfoEXT::operator=(const safe_VkDebugMarkerMarkerInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pMarkerName) delete [] pMarkerName;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
pMarkerName = SafeStringCopy(copy_src.pMarkerName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = copy_src.color[i];
}
return *this;
}
safe_VkDebugMarkerMarkerInfoEXT::~safe_VkDebugMarkerMarkerInfoEXT()
{
if (pMarkerName) delete [] pMarkerName;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugMarkerMarkerInfoEXT::initialize(const VkDebugMarkerMarkerInfoEXT* in_struct)
{
sType = in_struct->sType;
pNext = SafePnextCopy(in_struct->pNext);
pMarkerName = SafeStringCopy(in_struct->pMarkerName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = in_struct->color[i];
}
}
void safe_VkDebugMarkerMarkerInfoEXT::initialize(const safe_VkDebugMarkerMarkerInfoEXT* copy_src)
{
sType = copy_src->sType;
pNext = SafePnextCopy(copy_src->pNext);
pMarkerName = SafeStringCopy(copy_src->pMarkerName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = copy_src->color[i];
}
}
safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct) :
sType(in_struct->sType),
dedicatedAllocation(in_struct->dedicatedAllocation)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src)
{
sType = copy_src.sType;
dedicatedAllocation = copy_src.dedicatedAllocation;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDedicatedAllocationImageCreateInfoNV& safe_VkDedicatedAllocationImageCreateInfoNV::operator=(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
dedicatedAllocation = copy_src.dedicatedAllocation;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDedicatedAllocationImageCreateInfoNV::~safe_VkDedicatedAllocationImageCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct)
{
sType = in_struct->sType;
dedicatedAllocation = in_struct->dedicatedAllocation;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* copy_src)
{
sType = copy_src->sType;
dedicatedAllocation = copy_src->dedicatedAllocation;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct) :
sType(in_struct->sType),
dedicatedAllocation(in_struct->dedicatedAllocation)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src)
{
sType = copy_src.sType;
dedicatedAllocation = copy_src.dedicatedAllocation;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDedicatedAllocationBufferCreateInfoNV& safe_VkDedicatedAllocationBufferCreateInfoNV::operator=(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
dedicatedAllocation = copy_src.dedicatedAllocation;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDedicatedAllocationBufferCreateInfoNV::~safe_VkDedicatedAllocationBufferCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct)
{
sType = in_struct->sType;
dedicatedAllocation = in_struct->dedicatedAllocation;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* copy_src)
{
sType = copy_src->sType;
dedicatedAllocation = copy_src->dedicatedAllocation;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct) :
sType(in_struct->sType),
image(in_struct->image),
buffer(in_struct->buffer)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV() :
sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV),
pNext(nullptr)
{}
safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src)
{
sType = copy_src.sType;
image = copy_src.image;
buffer = copy_src.buffer;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDedicatedAllocationMemoryAllocateInfoNV& safe_VkDedicatedAllocationMemoryAllocateInfoNV::operator=(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
image = copy_src.image;
buffer = copy_src.buffer;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDedicatedAllocationMemoryAllocateInfoNV::~safe_VkDedicatedAllocationMemoryAllocateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct)
{
sType = in_struct->sType;
image = in_struct->image;
buffer = in_struct->buffer;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* copy_src)
{
sType = copy_src->sType;
image = copy_src->image;
buffer = copy_src->buffer;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct) :
sType(in_struct->sType),
transformFeedback(in_struct->transformFeedback),
geometryStreams(in_struct->geometryStreams)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src)
{
sType = copy_src.sType;
transformFeedback = copy_src.transformFeedback;
geometryStreams = copy_src.geometryStreams;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::operator=(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
transformFeedback = copy_src.transformFeedback;
geometryStreams = copy_src.geometryStreams;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct)
{
sType = in_struct->sType;
transformFeedback = in_struct->transformFeedback;
geometryStreams = in_struct->geometryStreams;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::initialize(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* copy_src)
{
sType = copy_src->sType;
transformFeedback = copy_src->transformFeedback;
geometryStreams = copy_src->geometryStreams;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct) :
sType(in_struct->sType),
maxTransformFeedbackStreams(in_struct->maxTransformFeedbackStreams),
maxTransformFeedbackBuffers(in_struct->maxTransformFeedbackBuffers),
maxTransformFeedbackBufferSize(in_struct->maxTransformFeedbackBufferSize),
maxTransformFeedbackStreamDataSize(in_struct->maxTransformFeedbackStreamDataSize),
maxTransformFeedbackBufferDataSize(in_struct->maxTransformFeedbackBufferDataSize),
maxTransformFeedbackBufferDataStride(in_struct->maxTransformFeedbackBufferDataStride),
transformFeedbackQueries(in_struct->transformFeedbackQueries),
transformFeedbackStreamsLinesTriangles(in_struct->transformFeedbackStreamsLinesTriangles),
transformFeedbackRasterizationStreamSelect(in_struct->transformFeedbackRasterizationStreamSelect),
transformFeedbackDraw(in_struct->transformFeedbackDraw)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src)
{
sType = copy_src.sType;
maxTransformFeedbackStreams = copy_src.maxTransformFeedbackStreams;
maxTransformFeedbackBuffers = copy_src.maxTransformFeedbackBuffers;
maxTransformFeedbackBufferSize = copy_src.maxTransformFeedbackBufferSize;
maxTransformFeedbackStreamDataSize = copy_src.maxTransformFeedbackStreamDataSize;
maxTransformFeedbackBufferDataSize = copy_src.maxTransformFeedbackBufferDataSize;
maxTransformFeedbackBufferDataStride = copy_src.maxTransformFeedbackBufferDataStride;
transformFeedbackQueries = copy_src.transformFeedbackQueries;
transformFeedbackStreamsLinesTriangles = copy_src.transformFeedbackStreamsLinesTriangles;
transformFeedbackRasterizationStreamSelect = copy_src.transformFeedbackRasterizationStreamSelect;
transformFeedbackDraw = copy_src.transformFeedbackDraw;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::operator=(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxTransformFeedbackStreams = copy_src.maxTransformFeedbackStreams;
maxTransformFeedbackBuffers = copy_src.maxTransformFeedbackBuffers;
maxTransformFeedbackBufferSize = copy_src.maxTransformFeedbackBufferSize;
maxTransformFeedbackStreamDataSize = copy_src.maxTransformFeedbackStreamDataSize;
maxTransformFeedbackBufferDataSize = copy_src.maxTransformFeedbackBufferDataSize;
maxTransformFeedbackBufferDataStride = copy_src.maxTransformFeedbackBufferDataStride;
transformFeedbackQueries = copy_src.transformFeedbackQueries;
transformFeedbackStreamsLinesTriangles = copy_src.transformFeedbackStreamsLinesTriangles;
transformFeedbackRasterizationStreamSelect = copy_src.transformFeedbackRasterizationStreamSelect;
transformFeedbackDraw = copy_src.transformFeedbackDraw;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct)
{
sType = in_struct->sType;
maxTransformFeedbackStreams = in_struct->maxTransformFeedbackStreams;
maxTransformFeedbackBuffers = in_struct->maxTransformFeedbackBuffers;
maxTransformFeedbackBufferSize = in_struct->maxTransformFeedbackBufferSize;
maxTransformFeedbackStreamDataSize = in_struct->maxTransformFeedbackStreamDataSize;
maxTransformFeedbackBufferDataSize = in_struct->maxTransformFeedbackBufferDataSize;
maxTransformFeedbackBufferDataStride = in_struct->maxTransformFeedbackBufferDataStride;
transformFeedbackQueries = in_struct->transformFeedbackQueries;
transformFeedbackStreamsLinesTriangles = in_struct->transformFeedbackStreamsLinesTriangles;
transformFeedbackRasterizationStreamSelect = in_struct->transformFeedbackRasterizationStreamSelect;
transformFeedbackDraw = in_struct->transformFeedbackDraw;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* copy_src)
{
sType = copy_src->sType;
maxTransformFeedbackStreams = copy_src->maxTransformFeedbackStreams;
maxTransformFeedbackBuffers = copy_src->maxTransformFeedbackBuffers;
maxTransformFeedbackBufferSize = copy_src->maxTransformFeedbackBufferSize;
maxTransformFeedbackStreamDataSize = copy_src->maxTransformFeedbackStreamDataSize;
maxTransformFeedbackBufferDataSize = copy_src->maxTransformFeedbackBufferDataSize;
maxTransformFeedbackBufferDataStride = copy_src->maxTransformFeedbackBufferDataStride;
transformFeedbackQueries = copy_src->transformFeedbackQueries;
transformFeedbackStreamsLinesTriangles = copy_src->transformFeedbackStreamsLinesTriangles;
transformFeedbackRasterizationStreamSelect = copy_src->transformFeedbackRasterizationStreamSelect;
transformFeedbackDraw = copy_src->transformFeedbackDraw;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
rasterizationStream(in_struct->rasterizationStream)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
rasterizationStream = copy_src.rasterizationStream;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineRasterizationStateStreamCreateInfoEXT& safe_VkPipelineRasterizationStateStreamCreateInfoEXT::operator=(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
rasterizationStream = copy_src.rasterizationStream;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineRasterizationStateStreamCreateInfoEXT::~safe_VkPipelineRasterizationStateStreamCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
rasterizationStream = in_struct->rasterizationStream;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
rasterizationStream = copy_src->rasterizationStream;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct) :
sType(in_struct->sType),
imageView(in_struct->imageView),
descriptorType(in_struct->descriptorType),
sampler(in_struct->sampler)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX() :
sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX),
pNext(nullptr)
{}
safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& copy_src)
{
sType = copy_src.sType;
imageView = copy_src.imageView;
descriptorType = copy_src.descriptorType;
sampler = copy_src.sampler;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageViewHandleInfoNVX& safe_VkImageViewHandleInfoNVX::operator=(const safe_VkImageViewHandleInfoNVX& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
imageView = copy_src.imageView;
descriptorType = copy_src.descriptorType;
sampler = copy_src.sampler;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageViewHandleInfoNVX::~safe_VkImageViewHandleInfoNVX()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageViewHandleInfoNVX::initialize(const VkImageViewHandleInfoNVX* in_struct)
{
sType = in_struct->sType;
imageView = in_struct->imageView;
descriptorType = in_struct->descriptorType;
sampler = in_struct->sampler;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageViewHandleInfoNVX::initialize(const safe_VkImageViewHandleInfoNVX* copy_src)
{
sType = copy_src->sType;
imageView = copy_src->imageView;
descriptorType = copy_src->descriptorType;
sampler = copy_src->sampler;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* in_struct) :
sType(in_struct->sType),
deviceAddress(in_struct->deviceAddress),
size(in_struct->size)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX() :
sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX),
pNext(nullptr)
{}
safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX(const safe_VkImageViewAddressPropertiesNVX& copy_src)
{
sType = copy_src.sType;
deviceAddress = copy_src.deviceAddress;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageViewAddressPropertiesNVX& safe_VkImageViewAddressPropertiesNVX::operator=(const safe_VkImageViewAddressPropertiesNVX& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceAddress = copy_src.deviceAddress;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageViewAddressPropertiesNVX::~safe_VkImageViewAddressPropertiesNVX()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageViewAddressPropertiesNVX::initialize(const VkImageViewAddressPropertiesNVX* in_struct)
{
sType = in_struct->sType;
deviceAddress = in_struct->deviceAddress;
size = in_struct->size;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageViewAddressPropertiesNVX::initialize(const safe_VkImageViewAddressPropertiesNVX* copy_src)
{
sType = copy_src->sType;
deviceAddress = copy_src->deviceAddress;
size = copy_src->size;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264CapabilitiesEXT::safe_VkVideoEncodeH264CapabilitiesEXT(const VkVideoEncodeH264CapabilitiesEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
inputModeFlags(in_struct->inputModeFlags),
outputModeFlags(in_struct->outputModeFlags),
minPictureSizeInMbs(in_struct->minPictureSizeInMbs),
maxPictureSizeInMbs(in_struct->maxPictureSizeInMbs),
inputImageDataAlignment(in_struct->inputImageDataAlignment),
maxNumL0ReferenceForP(in_struct->maxNumL0ReferenceForP),
maxNumL0ReferenceForB(in_struct->maxNumL0ReferenceForB),
maxNumL1Reference(in_struct->maxNumL1Reference),
qualityLevelCount(in_struct->qualityLevelCount),
stdExtensionVersion(in_struct->stdExtensionVersion)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoEncodeH264CapabilitiesEXT::safe_VkVideoEncodeH264CapabilitiesEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT),
pNext(nullptr)
{}
safe_VkVideoEncodeH264CapabilitiesEXT::safe_VkVideoEncodeH264CapabilitiesEXT(const safe_VkVideoEncodeH264CapabilitiesEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
inputModeFlags = copy_src.inputModeFlags;
outputModeFlags = copy_src.outputModeFlags;
minPictureSizeInMbs = copy_src.minPictureSizeInMbs;
maxPictureSizeInMbs = copy_src.maxPictureSizeInMbs;
inputImageDataAlignment = copy_src.inputImageDataAlignment;
maxNumL0ReferenceForP = copy_src.maxNumL0ReferenceForP;
maxNumL0ReferenceForB = copy_src.maxNumL0ReferenceForB;
maxNumL1Reference = copy_src.maxNumL1Reference;
qualityLevelCount = copy_src.qualityLevelCount;
stdExtensionVersion = copy_src.stdExtensionVersion;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoEncodeH264CapabilitiesEXT& safe_VkVideoEncodeH264CapabilitiesEXT::operator=(const safe_VkVideoEncodeH264CapabilitiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
inputModeFlags = copy_src.inputModeFlags;
outputModeFlags = copy_src.outputModeFlags;
minPictureSizeInMbs = copy_src.minPictureSizeInMbs;
maxPictureSizeInMbs = copy_src.maxPictureSizeInMbs;
inputImageDataAlignment = copy_src.inputImageDataAlignment;
maxNumL0ReferenceForP = copy_src.maxNumL0ReferenceForP;
maxNumL0ReferenceForB = copy_src.maxNumL0ReferenceForB;
maxNumL1Reference = copy_src.maxNumL1Reference;
qualityLevelCount = copy_src.qualityLevelCount;
stdExtensionVersion = copy_src.stdExtensionVersion;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoEncodeH264CapabilitiesEXT::~safe_VkVideoEncodeH264CapabilitiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264CapabilitiesEXT::initialize(const VkVideoEncodeH264CapabilitiesEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
inputModeFlags = in_struct->inputModeFlags;
outputModeFlags = in_struct->outputModeFlags;
minPictureSizeInMbs = in_struct->minPictureSizeInMbs;
maxPictureSizeInMbs = in_struct->maxPictureSizeInMbs;
inputImageDataAlignment = in_struct->inputImageDataAlignment;
maxNumL0ReferenceForP = in_struct->maxNumL0ReferenceForP;
maxNumL0ReferenceForB = in_struct->maxNumL0ReferenceForB;
maxNumL1Reference = in_struct->maxNumL1Reference;
qualityLevelCount = in_struct->qualityLevelCount;
stdExtensionVersion = in_struct->stdExtensionVersion;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoEncodeH264CapabilitiesEXT::initialize(const safe_VkVideoEncodeH264CapabilitiesEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
inputModeFlags = copy_src->inputModeFlags;
outputModeFlags = copy_src->outputModeFlags;
minPictureSizeInMbs = copy_src->minPictureSizeInMbs;
maxPictureSizeInMbs = copy_src->maxPictureSizeInMbs;
inputImageDataAlignment = copy_src->inputImageDataAlignment;
maxNumL0ReferenceForP = copy_src->maxNumL0ReferenceForP;
maxNumL0ReferenceForB = copy_src->maxNumL0ReferenceForB;
maxNumL1Reference = copy_src->maxNumL1Reference;
qualityLevelCount = copy_src->qualityLevelCount;
stdExtensionVersion = copy_src->stdExtensionVersion;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264SessionCreateInfoEXT::safe_VkVideoEncodeH264SessionCreateInfoEXT(const VkVideoEncodeH264SessionCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
maxPictureSizeInMbs(in_struct->maxPictureSizeInMbs),
pStdExtensionVersion(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*in_struct->pStdExtensionVersion);
}
}
safe_VkVideoEncodeH264SessionCreateInfoEXT::safe_VkVideoEncodeH264SessionCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT),
pNext(nullptr),
pStdExtensionVersion(nullptr)
{}
safe_VkVideoEncodeH264SessionCreateInfoEXT::safe_VkVideoEncodeH264SessionCreateInfoEXT(const safe_VkVideoEncodeH264SessionCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
maxPictureSizeInMbs = copy_src.maxPictureSizeInMbs;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src.pStdExtensionVersion);
}
}
safe_VkVideoEncodeH264SessionCreateInfoEXT& safe_VkVideoEncodeH264SessionCreateInfoEXT::operator=(const safe_VkVideoEncodeH264SessionCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdExtensionVersion)
delete pStdExtensionVersion;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
maxPictureSizeInMbs = copy_src.maxPictureSizeInMbs;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src.pStdExtensionVersion);
}
return *this;
}
safe_VkVideoEncodeH264SessionCreateInfoEXT::~safe_VkVideoEncodeH264SessionCreateInfoEXT()
{
if (pStdExtensionVersion)
delete pStdExtensionVersion;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264SessionCreateInfoEXT::initialize(const VkVideoEncodeH264SessionCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
maxPictureSizeInMbs = in_struct->maxPictureSizeInMbs;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*in_struct->pStdExtensionVersion);
}
}
void safe_VkVideoEncodeH264SessionCreateInfoEXT::initialize(const safe_VkVideoEncodeH264SessionCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
maxPictureSizeInMbs = copy_src->maxPictureSizeInMbs;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src->pStdExtensionVersion);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264SessionParametersAddInfoEXT::safe_VkVideoEncodeH264SessionParametersAddInfoEXT(const VkVideoEncodeH264SessionParametersAddInfoEXT* in_struct) :
sType(in_struct->sType),
spsStdCount(in_struct->spsStdCount),
pSpsStd(nullptr),
ppsStdCount(in_struct->ppsStdCount),
pPpsStd(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[in_struct->spsStdCount];
memcpy ((void *)pSpsStd, (void *)in_struct->pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*in_struct->spsStdCount);
}
if (in_struct->pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[in_struct->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)in_struct->pPpsStd, sizeof(StdVideoH264PictureParameterSet)*in_struct->ppsStdCount);
}
}
safe_VkVideoEncodeH264SessionParametersAddInfoEXT::safe_VkVideoEncodeH264SessionParametersAddInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT),
pNext(nullptr),
pSpsStd(nullptr),
pPpsStd(nullptr)
{}
safe_VkVideoEncodeH264SessionParametersAddInfoEXT::safe_VkVideoEncodeH264SessionParametersAddInfoEXT(const safe_VkVideoEncodeH264SessionParametersAddInfoEXT& copy_src)
{
sType = copy_src.sType;
spsStdCount = copy_src.spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src.ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[copy_src.spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src.pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*copy_src.spsStdCount);
}
if (copy_src.pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[copy_src.ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src.pPpsStd, sizeof(StdVideoH264PictureParameterSet)*copy_src.ppsStdCount);
}
}
safe_VkVideoEncodeH264SessionParametersAddInfoEXT& safe_VkVideoEncodeH264SessionParametersAddInfoEXT::operator=(const safe_VkVideoEncodeH264SessionParametersAddInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pSpsStd)
delete[] pSpsStd;
if (pPpsStd)
delete[] pPpsStd;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
spsStdCount = copy_src.spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src.ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[copy_src.spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src.pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*copy_src.spsStdCount);
}
if (copy_src.pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[copy_src.ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src.pPpsStd, sizeof(StdVideoH264PictureParameterSet)*copy_src.ppsStdCount);
}
return *this;
}
safe_VkVideoEncodeH264SessionParametersAddInfoEXT::~safe_VkVideoEncodeH264SessionParametersAddInfoEXT()
{
if (pSpsStd)
delete[] pSpsStd;
if (pPpsStd)
delete[] pPpsStd;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264SessionParametersAddInfoEXT::initialize(const VkVideoEncodeH264SessionParametersAddInfoEXT* in_struct)
{
sType = in_struct->sType;
spsStdCount = in_struct->spsStdCount;
pSpsStd = nullptr;
ppsStdCount = in_struct->ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[in_struct->spsStdCount];
memcpy ((void *)pSpsStd, (void *)in_struct->pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*in_struct->spsStdCount);
}
if (in_struct->pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[in_struct->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)in_struct->pPpsStd, sizeof(StdVideoH264PictureParameterSet)*in_struct->ppsStdCount);
}
}
void safe_VkVideoEncodeH264SessionParametersAddInfoEXT::initialize(const safe_VkVideoEncodeH264SessionParametersAddInfoEXT* copy_src)
{
sType = copy_src->sType;
spsStdCount = copy_src->spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src->ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[copy_src->spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src->pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*copy_src->spsStdCount);
}
if (copy_src->pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[copy_src->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src->pPpsStd, sizeof(StdVideoH264PictureParameterSet)*copy_src->ppsStdCount);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::safe_VkVideoEncodeH264SessionParametersCreateInfoEXT(const VkVideoEncodeH264SessionParametersCreateInfoEXT* in_struct) :
sType(in_struct->sType),
maxSpsStdCount(in_struct->maxSpsStdCount),
maxPpsStdCount(in_struct->maxPpsStdCount),
pParametersAddInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(in_struct->pParametersAddInfo);
}
safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::safe_VkVideoEncodeH264SessionParametersCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT),
pNext(nullptr),
pParametersAddInfo(nullptr)
{}
safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::safe_VkVideoEncodeH264SessionParametersCreateInfoEXT(const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
maxSpsStdCount = copy_src.maxSpsStdCount;
maxPpsStdCount = copy_src.maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo);
}
safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::operator=(const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pParametersAddInfo)
delete pParametersAddInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxSpsStdCount = copy_src.maxSpsStdCount;
maxPpsStdCount = copy_src.maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo);
return *this;
}
safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::~safe_VkVideoEncodeH264SessionParametersCreateInfoEXT()
{
if (pParametersAddInfo)
delete pParametersAddInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::initialize(const VkVideoEncodeH264SessionParametersCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
maxSpsStdCount = in_struct->maxSpsStdCount;
maxPpsStdCount = in_struct->maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(in_struct->pParametersAddInfo);
}
void safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::initialize(const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
maxSpsStdCount = copy_src->maxSpsStdCount;
maxPpsStdCount = copy_src->maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(*copy_src->pParametersAddInfo);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264DpbSlotInfoEXT::safe_VkVideoEncodeH264DpbSlotInfoEXT(const VkVideoEncodeH264DpbSlotInfoEXT* in_struct) :
sType(in_struct->sType),
slotIndex(in_struct->slotIndex),
pStdPictureInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdPictureInfo) {
pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*in_struct->pStdPictureInfo);
}
}
safe_VkVideoEncodeH264DpbSlotInfoEXT::safe_VkVideoEncodeH264DpbSlotInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT),
pNext(nullptr),
pStdPictureInfo(nullptr)
{}
safe_VkVideoEncodeH264DpbSlotInfoEXT::safe_VkVideoEncodeH264DpbSlotInfoEXT(const safe_VkVideoEncodeH264DpbSlotInfoEXT& copy_src)
{
sType = copy_src.sType;
slotIndex = copy_src.slotIndex;
pStdPictureInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdPictureInfo) {
pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src.pStdPictureInfo);
}
}
safe_VkVideoEncodeH264DpbSlotInfoEXT& safe_VkVideoEncodeH264DpbSlotInfoEXT::operator=(const safe_VkVideoEncodeH264DpbSlotInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdPictureInfo)
delete pStdPictureInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
slotIndex = copy_src.slotIndex;
pStdPictureInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdPictureInfo) {
pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src.pStdPictureInfo);
}
return *this;
}
safe_VkVideoEncodeH264DpbSlotInfoEXT::~safe_VkVideoEncodeH264DpbSlotInfoEXT()
{
if (pStdPictureInfo)
delete pStdPictureInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264DpbSlotInfoEXT::initialize(const VkVideoEncodeH264DpbSlotInfoEXT* in_struct)
{
sType = in_struct->sType;
slotIndex = in_struct->slotIndex;
pStdPictureInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdPictureInfo) {
pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*in_struct->pStdPictureInfo);
}
}
void safe_VkVideoEncodeH264DpbSlotInfoEXT::initialize(const safe_VkVideoEncodeH264DpbSlotInfoEXT* copy_src)
{
sType = copy_src->sType;
slotIndex = copy_src->slotIndex;
pStdPictureInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdPictureInfo) {
pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src->pStdPictureInfo);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264NaluSliceEXT::safe_VkVideoEncodeH264NaluSliceEXT(const VkVideoEncodeH264NaluSliceEXT* in_struct) :
sType(in_struct->sType),
pSliceHeaderStd(nullptr),
mbCount(in_struct->mbCount),
refFinalList0EntryCount(in_struct->refFinalList0EntryCount),
pRefFinalList0Entries(nullptr),
refFinalList1EntryCount(in_struct->refFinalList1EntryCount),
pRefFinalList1Entries(nullptr),
precedingNaluBytes(in_struct->precedingNaluBytes),
minQp(in_struct->minQp),
maxQp(in_struct->maxQp)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSliceHeaderStd) {
pSliceHeaderStd = new StdVideoEncodeH264SliceHeader(*in_struct->pSliceHeaderStd);
}
if (refFinalList0EntryCount && in_struct->pRefFinalList0Entries) {
pRefFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList0EntryCount];
for (uint32_t i = 0; i < refFinalList0EntryCount; ++i) {
pRefFinalList0Entries[i].initialize(&in_struct->pRefFinalList0Entries[i]);
}
}
if (refFinalList1EntryCount && in_struct->pRefFinalList1Entries) {
pRefFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList1EntryCount];
for (uint32_t i = 0; i < refFinalList1EntryCount; ++i) {
pRefFinalList1Entries[i].initialize(&in_struct->pRefFinalList1Entries[i]);
}
}
}
safe_VkVideoEncodeH264NaluSliceEXT::safe_VkVideoEncodeH264NaluSliceEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT),
pNext(nullptr),
pSliceHeaderStd(nullptr),
pRefFinalList0Entries(nullptr),
pRefFinalList1Entries(nullptr)
{}
safe_VkVideoEncodeH264NaluSliceEXT::safe_VkVideoEncodeH264NaluSliceEXT(const safe_VkVideoEncodeH264NaluSliceEXT& copy_src)
{
sType = copy_src.sType;
pSliceHeaderStd = nullptr;
mbCount = copy_src.mbCount;
refFinalList0EntryCount = copy_src.refFinalList0EntryCount;
pRefFinalList0Entries = nullptr;
refFinalList1EntryCount = copy_src.refFinalList1EntryCount;
pRefFinalList1Entries = nullptr;
precedingNaluBytes = copy_src.precedingNaluBytes;
minQp = copy_src.minQp;
maxQp = copy_src.maxQp;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSliceHeaderStd) {
pSliceHeaderStd = new StdVideoEncodeH264SliceHeader(*copy_src.pSliceHeaderStd);
}
if (refFinalList0EntryCount && copy_src.pRefFinalList0Entries) {
pRefFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList0EntryCount];
for (uint32_t i = 0; i < refFinalList0EntryCount; ++i) {
pRefFinalList0Entries[i].initialize(&copy_src.pRefFinalList0Entries[i]);
}
}
if (refFinalList1EntryCount && copy_src.pRefFinalList1Entries) {
pRefFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList1EntryCount];
for (uint32_t i = 0; i < refFinalList1EntryCount; ++i) {
pRefFinalList1Entries[i].initialize(&copy_src.pRefFinalList1Entries[i]);
}
}
}
safe_VkVideoEncodeH264NaluSliceEXT& safe_VkVideoEncodeH264NaluSliceEXT::operator=(const safe_VkVideoEncodeH264NaluSliceEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pSliceHeaderStd)
delete pSliceHeaderStd;
if (pRefFinalList0Entries)
delete[] pRefFinalList0Entries;
if (pRefFinalList1Entries)
delete[] pRefFinalList1Entries;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pSliceHeaderStd = nullptr;
mbCount = copy_src.mbCount;
refFinalList0EntryCount = copy_src.refFinalList0EntryCount;
pRefFinalList0Entries = nullptr;
refFinalList1EntryCount = copy_src.refFinalList1EntryCount;
pRefFinalList1Entries = nullptr;
precedingNaluBytes = copy_src.precedingNaluBytes;
minQp = copy_src.minQp;
maxQp = copy_src.maxQp;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSliceHeaderStd) {
pSliceHeaderStd = new StdVideoEncodeH264SliceHeader(*copy_src.pSliceHeaderStd);
}
if (refFinalList0EntryCount && copy_src.pRefFinalList0Entries) {
pRefFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList0EntryCount];
for (uint32_t i = 0; i < refFinalList0EntryCount; ++i) {
pRefFinalList0Entries[i].initialize(&copy_src.pRefFinalList0Entries[i]);
}
}
if (refFinalList1EntryCount && copy_src.pRefFinalList1Entries) {
pRefFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList1EntryCount];
for (uint32_t i = 0; i < refFinalList1EntryCount; ++i) {
pRefFinalList1Entries[i].initialize(&copy_src.pRefFinalList1Entries[i]);
}
}
return *this;
}
safe_VkVideoEncodeH264NaluSliceEXT::~safe_VkVideoEncodeH264NaluSliceEXT()
{
if (pSliceHeaderStd)
delete pSliceHeaderStd;
if (pRefFinalList0Entries)
delete[] pRefFinalList0Entries;
if (pRefFinalList1Entries)
delete[] pRefFinalList1Entries;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264NaluSliceEXT::initialize(const VkVideoEncodeH264NaluSliceEXT* in_struct)
{
sType = in_struct->sType;
pSliceHeaderStd = nullptr;
mbCount = in_struct->mbCount;
refFinalList0EntryCount = in_struct->refFinalList0EntryCount;
pRefFinalList0Entries = nullptr;
refFinalList1EntryCount = in_struct->refFinalList1EntryCount;
pRefFinalList1Entries = nullptr;
precedingNaluBytes = in_struct->precedingNaluBytes;
minQp = in_struct->minQp;
maxQp = in_struct->maxQp;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSliceHeaderStd) {
pSliceHeaderStd = new StdVideoEncodeH264SliceHeader(*in_struct->pSliceHeaderStd);
}
if (refFinalList0EntryCount && in_struct->pRefFinalList0Entries) {
pRefFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList0EntryCount];
for (uint32_t i = 0; i < refFinalList0EntryCount; ++i) {
pRefFinalList0Entries[i].initialize(&in_struct->pRefFinalList0Entries[i]);
}
}
if (refFinalList1EntryCount && in_struct->pRefFinalList1Entries) {
pRefFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList1EntryCount];
for (uint32_t i = 0; i < refFinalList1EntryCount; ++i) {
pRefFinalList1Entries[i].initialize(&in_struct->pRefFinalList1Entries[i]);
}
}
}
void safe_VkVideoEncodeH264NaluSliceEXT::initialize(const safe_VkVideoEncodeH264NaluSliceEXT* copy_src)
{
sType = copy_src->sType;
pSliceHeaderStd = nullptr;
mbCount = copy_src->mbCount;
refFinalList0EntryCount = copy_src->refFinalList0EntryCount;
pRefFinalList0Entries = nullptr;
refFinalList1EntryCount = copy_src->refFinalList1EntryCount;
pRefFinalList1Entries = nullptr;
precedingNaluBytes = copy_src->precedingNaluBytes;
minQp = copy_src->minQp;
maxQp = copy_src->maxQp;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pSliceHeaderStd) {
pSliceHeaderStd = new StdVideoEncodeH264SliceHeader(*copy_src->pSliceHeaderStd);
}
if (refFinalList0EntryCount && copy_src->pRefFinalList0Entries) {
pRefFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList0EntryCount];
for (uint32_t i = 0; i < refFinalList0EntryCount; ++i) {
pRefFinalList0Entries[i].initialize(&copy_src->pRefFinalList0Entries[i]);
}
}
if (refFinalList1EntryCount && copy_src->pRefFinalList1Entries) {
pRefFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refFinalList1EntryCount];
for (uint32_t i = 0; i < refFinalList1EntryCount; ++i) {
pRefFinalList1Entries[i].initialize(&copy_src->pRefFinalList1Entries[i]);
}
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264VclFrameInfoEXT::safe_VkVideoEncodeH264VclFrameInfoEXT(const VkVideoEncodeH264VclFrameInfoEXT* in_struct) :
sType(in_struct->sType),
refDefaultFinalList0EntryCount(in_struct->refDefaultFinalList0EntryCount),
pRefDefaultFinalList0Entries(nullptr),
refDefaultFinalList1EntryCount(in_struct->refDefaultFinalList1EntryCount),
pRefDefaultFinalList1Entries(nullptr),
naluSliceEntryCount(in_struct->naluSliceEntryCount),
pNaluSliceEntries(nullptr),
pCurrentPictureInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (refDefaultFinalList0EntryCount && in_struct->pRefDefaultFinalList0Entries) {
pRefDefaultFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList0EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList0EntryCount; ++i) {
pRefDefaultFinalList0Entries[i].initialize(&in_struct->pRefDefaultFinalList0Entries[i]);
}
}
if (refDefaultFinalList1EntryCount && in_struct->pRefDefaultFinalList1Entries) {
pRefDefaultFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList1EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList1EntryCount; ++i) {
pRefDefaultFinalList1Entries[i].initialize(&in_struct->pRefDefaultFinalList1Entries[i]);
}
}
if (naluSliceEntryCount && in_struct->pNaluSliceEntries) {
pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceEXT[naluSliceEntryCount];
for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
pNaluSliceEntries[i].initialize(&in_struct->pNaluSliceEntries[i]);
}
}
if (in_struct->pCurrentPictureInfo)
pCurrentPictureInfo = new safe_VkVideoEncodeH264DpbSlotInfoEXT(in_struct->pCurrentPictureInfo);
}
safe_VkVideoEncodeH264VclFrameInfoEXT::safe_VkVideoEncodeH264VclFrameInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT),
pNext(nullptr),
pRefDefaultFinalList0Entries(nullptr),
pRefDefaultFinalList1Entries(nullptr),
pNaluSliceEntries(nullptr),
pCurrentPictureInfo(nullptr)
{}
safe_VkVideoEncodeH264VclFrameInfoEXT::safe_VkVideoEncodeH264VclFrameInfoEXT(const safe_VkVideoEncodeH264VclFrameInfoEXT& copy_src)
{
sType = copy_src.sType;
refDefaultFinalList0EntryCount = copy_src.refDefaultFinalList0EntryCount;
pRefDefaultFinalList0Entries = nullptr;
refDefaultFinalList1EntryCount = copy_src.refDefaultFinalList1EntryCount;
pRefDefaultFinalList1Entries = nullptr;
naluSliceEntryCount = copy_src.naluSliceEntryCount;
pNaluSliceEntries = nullptr;
pCurrentPictureInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (refDefaultFinalList0EntryCount && copy_src.pRefDefaultFinalList0Entries) {
pRefDefaultFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList0EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList0EntryCount; ++i) {
pRefDefaultFinalList0Entries[i].initialize(&copy_src.pRefDefaultFinalList0Entries[i]);
}
}
if (refDefaultFinalList1EntryCount && copy_src.pRefDefaultFinalList1Entries) {
pRefDefaultFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList1EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList1EntryCount; ++i) {
pRefDefaultFinalList1Entries[i].initialize(&copy_src.pRefDefaultFinalList1Entries[i]);
}
}
if (naluSliceEntryCount && copy_src.pNaluSliceEntries) {
pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceEXT[naluSliceEntryCount];
for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
pNaluSliceEntries[i].initialize(&copy_src.pNaluSliceEntries[i]);
}
}
if (copy_src.pCurrentPictureInfo)
pCurrentPictureInfo = new safe_VkVideoEncodeH264DpbSlotInfoEXT(*copy_src.pCurrentPictureInfo);
}
safe_VkVideoEncodeH264VclFrameInfoEXT& safe_VkVideoEncodeH264VclFrameInfoEXT::operator=(const safe_VkVideoEncodeH264VclFrameInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pRefDefaultFinalList0Entries)
delete[] pRefDefaultFinalList0Entries;
if (pRefDefaultFinalList1Entries)
delete[] pRefDefaultFinalList1Entries;
if (pNaluSliceEntries)
delete[] pNaluSliceEntries;
if (pCurrentPictureInfo)
delete pCurrentPictureInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
refDefaultFinalList0EntryCount = copy_src.refDefaultFinalList0EntryCount;
pRefDefaultFinalList0Entries = nullptr;
refDefaultFinalList1EntryCount = copy_src.refDefaultFinalList1EntryCount;
pRefDefaultFinalList1Entries = nullptr;
naluSliceEntryCount = copy_src.naluSliceEntryCount;
pNaluSliceEntries = nullptr;
pCurrentPictureInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (refDefaultFinalList0EntryCount && copy_src.pRefDefaultFinalList0Entries) {
pRefDefaultFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList0EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList0EntryCount; ++i) {
pRefDefaultFinalList0Entries[i].initialize(&copy_src.pRefDefaultFinalList0Entries[i]);
}
}
if (refDefaultFinalList1EntryCount && copy_src.pRefDefaultFinalList1Entries) {
pRefDefaultFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList1EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList1EntryCount; ++i) {
pRefDefaultFinalList1Entries[i].initialize(&copy_src.pRefDefaultFinalList1Entries[i]);
}
}
if (naluSliceEntryCount && copy_src.pNaluSliceEntries) {
pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceEXT[naluSliceEntryCount];
for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
pNaluSliceEntries[i].initialize(&copy_src.pNaluSliceEntries[i]);
}
}
if (copy_src.pCurrentPictureInfo)
pCurrentPictureInfo = new safe_VkVideoEncodeH264DpbSlotInfoEXT(*copy_src.pCurrentPictureInfo);
return *this;
}
safe_VkVideoEncodeH264VclFrameInfoEXT::~safe_VkVideoEncodeH264VclFrameInfoEXT()
{
if (pRefDefaultFinalList0Entries)
delete[] pRefDefaultFinalList0Entries;
if (pRefDefaultFinalList1Entries)
delete[] pRefDefaultFinalList1Entries;
if (pNaluSliceEntries)
delete[] pNaluSliceEntries;
if (pCurrentPictureInfo)
delete pCurrentPictureInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264VclFrameInfoEXT::initialize(const VkVideoEncodeH264VclFrameInfoEXT* in_struct)
{
sType = in_struct->sType;
refDefaultFinalList0EntryCount = in_struct->refDefaultFinalList0EntryCount;
pRefDefaultFinalList0Entries = nullptr;
refDefaultFinalList1EntryCount = in_struct->refDefaultFinalList1EntryCount;
pRefDefaultFinalList1Entries = nullptr;
naluSliceEntryCount = in_struct->naluSliceEntryCount;
pNaluSliceEntries = nullptr;
pCurrentPictureInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (refDefaultFinalList0EntryCount && in_struct->pRefDefaultFinalList0Entries) {
pRefDefaultFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList0EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList0EntryCount; ++i) {
pRefDefaultFinalList0Entries[i].initialize(&in_struct->pRefDefaultFinalList0Entries[i]);
}
}
if (refDefaultFinalList1EntryCount && in_struct->pRefDefaultFinalList1Entries) {
pRefDefaultFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList1EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList1EntryCount; ++i) {
pRefDefaultFinalList1Entries[i].initialize(&in_struct->pRefDefaultFinalList1Entries[i]);
}
}
if (naluSliceEntryCount && in_struct->pNaluSliceEntries) {
pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceEXT[naluSliceEntryCount];
for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
pNaluSliceEntries[i].initialize(&in_struct->pNaluSliceEntries[i]);
}
}
if (in_struct->pCurrentPictureInfo)
pCurrentPictureInfo = new safe_VkVideoEncodeH264DpbSlotInfoEXT(in_struct->pCurrentPictureInfo);
}
void safe_VkVideoEncodeH264VclFrameInfoEXT::initialize(const safe_VkVideoEncodeH264VclFrameInfoEXT* copy_src)
{
sType = copy_src->sType;
refDefaultFinalList0EntryCount = copy_src->refDefaultFinalList0EntryCount;
pRefDefaultFinalList0Entries = nullptr;
refDefaultFinalList1EntryCount = copy_src->refDefaultFinalList1EntryCount;
pRefDefaultFinalList1Entries = nullptr;
naluSliceEntryCount = copy_src->naluSliceEntryCount;
pNaluSliceEntries = nullptr;
pCurrentPictureInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (refDefaultFinalList0EntryCount && copy_src->pRefDefaultFinalList0Entries) {
pRefDefaultFinalList0Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList0EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList0EntryCount; ++i) {
pRefDefaultFinalList0Entries[i].initialize(&copy_src->pRefDefaultFinalList0Entries[i]);
}
}
if (refDefaultFinalList1EntryCount && copy_src->pRefDefaultFinalList1Entries) {
pRefDefaultFinalList1Entries = new safe_VkVideoEncodeH264DpbSlotInfoEXT[refDefaultFinalList1EntryCount];
for (uint32_t i = 0; i < refDefaultFinalList1EntryCount; ++i) {
pRefDefaultFinalList1Entries[i].initialize(&copy_src->pRefDefaultFinalList1Entries[i]);
}
}
if (naluSliceEntryCount && copy_src->pNaluSliceEntries) {
pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceEXT[naluSliceEntryCount];
for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
pNaluSliceEntries[i].initialize(&copy_src->pNaluSliceEntries[i]);
}
}
if (copy_src->pCurrentPictureInfo)
pCurrentPictureInfo = new safe_VkVideoEncodeH264DpbSlotInfoEXT(*copy_src->pCurrentPictureInfo);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264EmitPictureParametersEXT::safe_VkVideoEncodeH264EmitPictureParametersEXT(const VkVideoEncodeH264EmitPictureParametersEXT* in_struct) :
sType(in_struct->sType),
spsId(in_struct->spsId),
emitSpsEnable(in_struct->emitSpsEnable),
ppsIdEntryCount(in_struct->ppsIdEntryCount),
ppsIdEntries(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->ppsIdEntries) {
ppsIdEntries = new uint8_t[in_struct->ppsIdEntryCount];
memcpy ((void *)ppsIdEntries, (void *)in_struct->ppsIdEntries, sizeof(uint8_t)*in_struct->ppsIdEntryCount);
}
}
safe_VkVideoEncodeH264EmitPictureParametersEXT::safe_VkVideoEncodeH264EmitPictureParametersEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT),
pNext(nullptr),
ppsIdEntries(nullptr)
{}
safe_VkVideoEncodeH264EmitPictureParametersEXT::safe_VkVideoEncodeH264EmitPictureParametersEXT(const safe_VkVideoEncodeH264EmitPictureParametersEXT& copy_src)
{
sType = copy_src.sType;
spsId = copy_src.spsId;
emitSpsEnable = copy_src.emitSpsEnable;
ppsIdEntryCount = copy_src.ppsIdEntryCount;
ppsIdEntries = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.ppsIdEntries) {
ppsIdEntries = new uint8_t[copy_src.ppsIdEntryCount];
memcpy ((void *)ppsIdEntries, (void *)copy_src.ppsIdEntries, sizeof(uint8_t)*copy_src.ppsIdEntryCount);
}
}
safe_VkVideoEncodeH264EmitPictureParametersEXT& safe_VkVideoEncodeH264EmitPictureParametersEXT::operator=(const safe_VkVideoEncodeH264EmitPictureParametersEXT& copy_src)
{
if (&copy_src == this) return *this;
if (ppsIdEntries)
delete[] ppsIdEntries;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
spsId = copy_src.spsId;
emitSpsEnable = copy_src.emitSpsEnable;
ppsIdEntryCount = copy_src.ppsIdEntryCount;
ppsIdEntries = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.ppsIdEntries) {
ppsIdEntries = new uint8_t[copy_src.ppsIdEntryCount];
memcpy ((void *)ppsIdEntries, (void *)copy_src.ppsIdEntries, sizeof(uint8_t)*copy_src.ppsIdEntryCount);
}
return *this;
}
safe_VkVideoEncodeH264EmitPictureParametersEXT::~safe_VkVideoEncodeH264EmitPictureParametersEXT()
{
if (ppsIdEntries)
delete[] ppsIdEntries;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264EmitPictureParametersEXT::initialize(const VkVideoEncodeH264EmitPictureParametersEXT* in_struct)
{
sType = in_struct->sType;
spsId = in_struct->spsId;
emitSpsEnable = in_struct->emitSpsEnable;
ppsIdEntryCount = in_struct->ppsIdEntryCount;
ppsIdEntries = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->ppsIdEntries) {
ppsIdEntries = new uint8_t[in_struct->ppsIdEntryCount];
memcpy ((void *)ppsIdEntries, (void *)in_struct->ppsIdEntries, sizeof(uint8_t)*in_struct->ppsIdEntryCount);
}
}
void safe_VkVideoEncodeH264EmitPictureParametersEXT::initialize(const safe_VkVideoEncodeH264EmitPictureParametersEXT* copy_src)
{
sType = copy_src->sType;
spsId = copy_src->spsId;
emitSpsEnable = copy_src->emitSpsEnable;
ppsIdEntryCount = copy_src->ppsIdEntryCount;
ppsIdEntries = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->ppsIdEntries) {
ppsIdEntries = new uint8_t[copy_src->ppsIdEntryCount];
memcpy ((void *)ppsIdEntries, (void *)copy_src->ppsIdEntries, sizeof(uint8_t)*copy_src->ppsIdEntryCount);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoEncodeH264ProfileEXT::safe_VkVideoEncodeH264ProfileEXT(const VkVideoEncodeH264ProfileEXT* in_struct) :
sType(in_struct->sType),
stdProfileIdc(in_struct->stdProfileIdc)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoEncodeH264ProfileEXT::safe_VkVideoEncodeH264ProfileEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT),
pNext(nullptr)
{}
safe_VkVideoEncodeH264ProfileEXT::safe_VkVideoEncodeH264ProfileEXT(const safe_VkVideoEncodeH264ProfileEXT& copy_src)
{
sType = copy_src.sType;
stdProfileIdc = copy_src.stdProfileIdc;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoEncodeH264ProfileEXT& safe_VkVideoEncodeH264ProfileEXT::operator=(const safe_VkVideoEncodeH264ProfileEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stdProfileIdc = copy_src.stdProfileIdc;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoEncodeH264ProfileEXT::~safe_VkVideoEncodeH264ProfileEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoEncodeH264ProfileEXT::initialize(const VkVideoEncodeH264ProfileEXT* in_struct)
{
sType = in_struct->sType;
stdProfileIdc = in_struct->stdProfileIdc;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoEncodeH264ProfileEXT::initialize(const safe_VkVideoEncodeH264ProfileEXT* copy_src)
{
sType = copy_src->sType;
stdProfileIdc = copy_src->stdProfileIdc;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH264ProfileEXT::safe_VkVideoDecodeH264ProfileEXT(const VkVideoDecodeH264ProfileEXT* in_struct) :
sType(in_struct->sType),
stdProfileIdc(in_struct->stdProfileIdc),
fieldLayout(in_struct->fieldLayout)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoDecodeH264ProfileEXT::safe_VkVideoDecodeH264ProfileEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT),
pNext(nullptr)
{}
safe_VkVideoDecodeH264ProfileEXT::safe_VkVideoDecodeH264ProfileEXT(const safe_VkVideoDecodeH264ProfileEXT& copy_src)
{
sType = copy_src.sType;
stdProfileIdc = copy_src.stdProfileIdc;
fieldLayout = copy_src.fieldLayout;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoDecodeH264ProfileEXT& safe_VkVideoDecodeH264ProfileEXT::operator=(const safe_VkVideoDecodeH264ProfileEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stdProfileIdc = copy_src.stdProfileIdc;
fieldLayout = copy_src.fieldLayout;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoDecodeH264ProfileEXT::~safe_VkVideoDecodeH264ProfileEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH264ProfileEXT::initialize(const VkVideoDecodeH264ProfileEXT* in_struct)
{
sType = in_struct->sType;
stdProfileIdc = in_struct->stdProfileIdc;
fieldLayout = in_struct->fieldLayout;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoDecodeH264ProfileEXT::initialize(const safe_VkVideoDecodeH264ProfileEXT* copy_src)
{
sType = copy_src->sType;
stdProfileIdc = copy_src->stdProfileIdc;
fieldLayout = copy_src->fieldLayout;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH264CapabilitiesEXT::safe_VkVideoDecodeH264CapabilitiesEXT(const VkVideoDecodeH264CapabilitiesEXT* in_struct) :
sType(in_struct->sType),
maxLevel(in_struct->maxLevel),
fieldOffsetGranularity(in_struct->fieldOffsetGranularity),
stdExtensionVersion(in_struct->stdExtensionVersion)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoDecodeH264CapabilitiesEXT::safe_VkVideoDecodeH264CapabilitiesEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT),
pNext(nullptr)
{}
safe_VkVideoDecodeH264CapabilitiesEXT::safe_VkVideoDecodeH264CapabilitiesEXT(const safe_VkVideoDecodeH264CapabilitiesEXT& copy_src)
{
sType = copy_src.sType;
maxLevel = copy_src.maxLevel;
fieldOffsetGranularity = copy_src.fieldOffsetGranularity;
stdExtensionVersion = copy_src.stdExtensionVersion;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoDecodeH264CapabilitiesEXT& safe_VkVideoDecodeH264CapabilitiesEXT::operator=(const safe_VkVideoDecodeH264CapabilitiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxLevel = copy_src.maxLevel;
fieldOffsetGranularity = copy_src.fieldOffsetGranularity;
stdExtensionVersion = copy_src.stdExtensionVersion;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoDecodeH264CapabilitiesEXT::~safe_VkVideoDecodeH264CapabilitiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH264CapabilitiesEXT::initialize(const VkVideoDecodeH264CapabilitiesEXT* in_struct)
{
sType = in_struct->sType;
maxLevel = in_struct->maxLevel;
fieldOffsetGranularity = in_struct->fieldOffsetGranularity;
stdExtensionVersion = in_struct->stdExtensionVersion;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoDecodeH264CapabilitiesEXT::initialize(const safe_VkVideoDecodeH264CapabilitiesEXT* copy_src)
{
sType = copy_src->sType;
maxLevel = copy_src->maxLevel;
fieldOffsetGranularity = copy_src->fieldOffsetGranularity;
stdExtensionVersion = copy_src->stdExtensionVersion;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH264SessionCreateInfoEXT::safe_VkVideoDecodeH264SessionCreateInfoEXT(const VkVideoDecodeH264SessionCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
pStdExtensionVersion(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*in_struct->pStdExtensionVersion);
}
}
safe_VkVideoDecodeH264SessionCreateInfoEXT::safe_VkVideoDecodeH264SessionCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT),
pNext(nullptr),
pStdExtensionVersion(nullptr)
{}
safe_VkVideoDecodeH264SessionCreateInfoEXT::safe_VkVideoDecodeH264SessionCreateInfoEXT(const safe_VkVideoDecodeH264SessionCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src.pStdExtensionVersion);
}
}
safe_VkVideoDecodeH264SessionCreateInfoEXT& safe_VkVideoDecodeH264SessionCreateInfoEXT::operator=(const safe_VkVideoDecodeH264SessionCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdExtensionVersion)
delete pStdExtensionVersion;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src.pStdExtensionVersion);
}
return *this;
}
safe_VkVideoDecodeH264SessionCreateInfoEXT::~safe_VkVideoDecodeH264SessionCreateInfoEXT()
{
if (pStdExtensionVersion)
delete pStdExtensionVersion;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH264SessionCreateInfoEXT::initialize(const VkVideoDecodeH264SessionCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*in_struct->pStdExtensionVersion);
}
}
void safe_VkVideoDecodeH264SessionCreateInfoEXT::initialize(const safe_VkVideoDecodeH264SessionCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src->pStdExtensionVersion);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH264SessionParametersAddInfoEXT::safe_VkVideoDecodeH264SessionParametersAddInfoEXT(const VkVideoDecodeH264SessionParametersAddInfoEXT* in_struct) :
sType(in_struct->sType),
spsStdCount(in_struct->spsStdCount),
pSpsStd(nullptr),
ppsStdCount(in_struct->ppsStdCount),
pPpsStd(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[in_struct->spsStdCount];
memcpy ((void *)pSpsStd, (void *)in_struct->pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*in_struct->spsStdCount);
}
if (in_struct->pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[in_struct->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)in_struct->pPpsStd, sizeof(StdVideoH264PictureParameterSet)*in_struct->ppsStdCount);
}
}
safe_VkVideoDecodeH264SessionParametersAddInfoEXT::safe_VkVideoDecodeH264SessionParametersAddInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT),
pNext(nullptr),
pSpsStd(nullptr),
pPpsStd(nullptr)
{}
safe_VkVideoDecodeH264SessionParametersAddInfoEXT::safe_VkVideoDecodeH264SessionParametersAddInfoEXT(const safe_VkVideoDecodeH264SessionParametersAddInfoEXT& copy_src)
{
sType = copy_src.sType;
spsStdCount = copy_src.spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src.ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[copy_src.spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src.pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*copy_src.spsStdCount);
}
if (copy_src.pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[copy_src.ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src.pPpsStd, sizeof(StdVideoH264PictureParameterSet)*copy_src.ppsStdCount);
}
}
safe_VkVideoDecodeH264SessionParametersAddInfoEXT& safe_VkVideoDecodeH264SessionParametersAddInfoEXT::operator=(const safe_VkVideoDecodeH264SessionParametersAddInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pSpsStd)
delete[] pSpsStd;
if (pPpsStd)
delete[] pPpsStd;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
spsStdCount = copy_src.spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src.ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[copy_src.spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src.pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*copy_src.spsStdCount);
}
if (copy_src.pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[copy_src.ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src.pPpsStd, sizeof(StdVideoH264PictureParameterSet)*copy_src.ppsStdCount);
}
return *this;
}
safe_VkVideoDecodeH264SessionParametersAddInfoEXT::~safe_VkVideoDecodeH264SessionParametersAddInfoEXT()
{
if (pSpsStd)
delete[] pSpsStd;
if (pPpsStd)
delete[] pPpsStd;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH264SessionParametersAddInfoEXT::initialize(const VkVideoDecodeH264SessionParametersAddInfoEXT* in_struct)
{
sType = in_struct->sType;
spsStdCount = in_struct->spsStdCount;
pSpsStd = nullptr;
ppsStdCount = in_struct->ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[in_struct->spsStdCount];
memcpy ((void *)pSpsStd, (void *)in_struct->pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*in_struct->spsStdCount);
}
if (in_struct->pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[in_struct->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)in_struct->pPpsStd, sizeof(StdVideoH264PictureParameterSet)*in_struct->ppsStdCount);
}
}
void safe_VkVideoDecodeH264SessionParametersAddInfoEXT::initialize(const safe_VkVideoDecodeH264SessionParametersAddInfoEXT* copy_src)
{
sType = copy_src->sType;
spsStdCount = copy_src->spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src->ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pSpsStd) {
pSpsStd = new StdVideoH264SequenceParameterSet[copy_src->spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src->pSpsStd, sizeof(StdVideoH264SequenceParameterSet)*copy_src->spsStdCount);
}
if (copy_src->pPpsStd) {
pPpsStd = new StdVideoH264PictureParameterSet[copy_src->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src->pPpsStd, sizeof(StdVideoH264PictureParameterSet)*copy_src->ppsStdCount);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH264SessionParametersCreateInfoEXT::safe_VkVideoDecodeH264SessionParametersCreateInfoEXT(const VkVideoDecodeH264SessionParametersCreateInfoEXT* in_struct) :
sType(in_struct->sType),
maxSpsStdCount(in_struct->maxSpsStdCount),
maxPpsStdCount(in_struct->maxPpsStdCount),
pParametersAddInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoEXT(in_struct->pParametersAddInfo);
}
safe_VkVideoDecodeH264SessionParametersCreateInfoEXT::safe_VkVideoDecodeH264SessionParametersCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT),
pNext(nullptr),
pParametersAddInfo(nullptr)
{}
safe_VkVideoDecodeH264SessionParametersCreateInfoEXT::safe_VkVideoDecodeH264SessionParametersCreateInfoEXT(const safe_VkVideoDecodeH264SessionParametersCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
maxSpsStdCount = copy_src.maxSpsStdCount;
maxPpsStdCount = copy_src.maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo);
}
safe_VkVideoDecodeH264SessionParametersCreateInfoEXT& safe_VkVideoDecodeH264SessionParametersCreateInfoEXT::operator=(const safe_VkVideoDecodeH264SessionParametersCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pParametersAddInfo)
delete pParametersAddInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxSpsStdCount = copy_src.maxSpsStdCount;
maxPpsStdCount = copy_src.maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo);
return *this;
}
safe_VkVideoDecodeH264SessionParametersCreateInfoEXT::~safe_VkVideoDecodeH264SessionParametersCreateInfoEXT()
{
if (pParametersAddInfo)
delete pParametersAddInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH264SessionParametersCreateInfoEXT::initialize(const VkVideoDecodeH264SessionParametersCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
maxSpsStdCount = in_struct->maxSpsStdCount;
maxPpsStdCount = in_struct->maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoEXT(in_struct->pParametersAddInfo);
}
void safe_VkVideoDecodeH264SessionParametersCreateInfoEXT::initialize(const safe_VkVideoDecodeH264SessionParametersCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
maxSpsStdCount = copy_src->maxSpsStdCount;
maxPpsStdCount = copy_src->maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoEXT(*copy_src->pParametersAddInfo);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH264PictureInfoEXT::safe_VkVideoDecodeH264PictureInfoEXT(const VkVideoDecodeH264PictureInfoEXT* in_struct) :
sType(in_struct->sType),
pStdPictureInfo(nullptr),
slicesCount(in_struct->slicesCount),
pSlicesDataOffsets(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*in_struct->pStdPictureInfo);
}
if (in_struct->pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[in_struct->slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)in_struct->pSlicesDataOffsets, sizeof(uint32_t)*in_struct->slicesCount);
}
}
safe_VkVideoDecodeH264PictureInfoEXT::safe_VkVideoDecodeH264PictureInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT),
pNext(nullptr),
pStdPictureInfo(nullptr),
pSlicesDataOffsets(nullptr)
{}
safe_VkVideoDecodeH264PictureInfoEXT::safe_VkVideoDecodeH264PictureInfoEXT(const safe_VkVideoDecodeH264PictureInfoEXT& copy_src)
{
sType = copy_src.sType;
pStdPictureInfo = nullptr;
slicesCount = copy_src.slicesCount;
pSlicesDataOffsets = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src.pStdPictureInfo);
}
if (copy_src.pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[copy_src.slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)copy_src.pSlicesDataOffsets, sizeof(uint32_t)*copy_src.slicesCount);
}
}
safe_VkVideoDecodeH264PictureInfoEXT& safe_VkVideoDecodeH264PictureInfoEXT::operator=(const safe_VkVideoDecodeH264PictureInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdPictureInfo)
delete pStdPictureInfo;
if (pSlicesDataOffsets)
delete[] pSlicesDataOffsets;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pStdPictureInfo = nullptr;
slicesCount = copy_src.slicesCount;
pSlicesDataOffsets = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src.pStdPictureInfo);
}
if (copy_src.pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[copy_src.slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)copy_src.pSlicesDataOffsets, sizeof(uint32_t)*copy_src.slicesCount);
}
return *this;
}
safe_VkVideoDecodeH264PictureInfoEXT::~safe_VkVideoDecodeH264PictureInfoEXT()
{
if (pStdPictureInfo)
delete pStdPictureInfo;
if (pSlicesDataOffsets)
delete[] pSlicesDataOffsets;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH264PictureInfoEXT::initialize(const VkVideoDecodeH264PictureInfoEXT* in_struct)
{
sType = in_struct->sType;
pStdPictureInfo = nullptr;
slicesCount = in_struct->slicesCount;
pSlicesDataOffsets = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*in_struct->pStdPictureInfo);
}
if (in_struct->pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[in_struct->slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)in_struct->pSlicesDataOffsets, sizeof(uint32_t)*in_struct->slicesCount);
}
}
void safe_VkVideoDecodeH264PictureInfoEXT::initialize(const safe_VkVideoDecodeH264PictureInfoEXT* copy_src)
{
sType = copy_src->sType;
pStdPictureInfo = nullptr;
slicesCount = copy_src->slicesCount;
pSlicesDataOffsets = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src->pStdPictureInfo);
}
if (copy_src->pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[copy_src->slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)copy_src->pSlicesDataOffsets, sizeof(uint32_t)*copy_src->slicesCount);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH264MvcEXT::safe_VkVideoDecodeH264MvcEXT(const VkVideoDecodeH264MvcEXT* in_struct) :
sType(in_struct->sType),
pStdMvc(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdMvc) {
pStdMvc = new StdVideoDecodeH264Mvc(*in_struct->pStdMvc);
}
}
safe_VkVideoDecodeH264MvcEXT::safe_VkVideoDecodeH264MvcEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT),
pNext(nullptr),
pStdMvc(nullptr)
{}
safe_VkVideoDecodeH264MvcEXT::safe_VkVideoDecodeH264MvcEXT(const safe_VkVideoDecodeH264MvcEXT& copy_src)
{
sType = copy_src.sType;
pStdMvc = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdMvc) {
pStdMvc = new StdVideoDecodeH264Mvc(*copy_src.pStdMvc);
}
}
safe_VkVideoDecodeH264MvcEXT& safe_VkVideoDecodeH264MvcEXT::operator=(const safe_VkVideoDecodeH264MvcEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdMvc)
delete pStdMvc;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pStdMvc = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdMvc) {
pStdMvc = new StdVideoDecodeH264Mvc(*copy_src.pStdMvc);
}
return *this;
}
safe_VkVideoDecodeH264MvcEXT::~safe_VkVideoDecodeH264MvcEXT()
{
if (pStdMvc)
delete pStdMvc;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH264MvcEXT::initialize(const VkVideoDecodeH264MvcEXT* in_struct)
{
sType = in_struct->sType;
pStdMvc = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdMvc) {
pStdMvc = new StdVideoDecodeH264Mvc(*in_struct->pStdMvc);
}
}
void safe_VkVideoDecodeH264MvcEXT::initialize(const safe_VkVideoDecodeH264MvcEXT* copy_src)
{
sType = copy_src->sType;
pStdMvc = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdMvc) {
pStdMvc = new StdVideoDecodeH264Mvc(*copy_src->pStdMvc);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH264DpbSlotInfoEXT::safe_VkVideoDecodeH264DpbSlotInfoEXT(const VkVideoDecodeH264DpbSlotInfoEXT* in_struct) :
sType(in_struct->sType),
pStdReferenceInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo);
}
}
safe_VkVideoDecodeH264DpbSlotInfoEXT::safe_VkVideoDecodeH264DpbSlotInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT),
pNext(nullptr),
pStdReferenceInfo(nullptr)
{}
safe_VkVideoDecodeH264DpbSlotInfoEXT::safe_VkVideoDecodeH264DpbSlotInfoEXT(const safe_VkVideoDecodeH264DpbSlotInfoEXT& copy_src)
{
sType = copy_src.sType;
pStdReferenceInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo);
}
}
safe_VkVideoDecodeH264DpbSlotInfoEXT& safe_VkVideoDecodeH264DpbSlotInfoEXT::operator=(const safe_VkVideoDecodeH264DpbSlotInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdReferenceInfo)
delete pStdReferenceInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pStdReferenceInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo);
}
return *this;
}
safe_VkVideoDecodeH264DpbSlotInfoEXT::~safe_VkVideoDecodeH264DpbSlotInfoEXT()
{
if (pStdReferenceInfo)
delete pStdReferenceInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH264DpbSlotInfoEXT::initialize(const VkVideoDecodeH264DpbSlotInfoEXT* in_struct)
{
sType = in_struct->sType;
pStdReferenceInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo);
}
}
void safe_VkVideoDecodeH264DpbSlotInfoEXT::initialize(const safe_VkVideoDecodeH264DpbSlotInfoEXT* copy_src)
{
sType = copy_src->sType;
pStdReferenceInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src->pStdReferenceInfo);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct) :
sType(in_struct->sType),
supportsTextureGatherLODBiasAMD(in_struct->supportsTextureGatherLODBiasAMD)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD() :
sType(VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD),
pNext(nullptr)
{}
safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src)
{
sType = copy_src.sType;
supportsTextureGatherLODBiasAMD = copy_src.supportsTextureGatherLODBiasAMD;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkTextureLODGatherFormatPropertiesAMD& safe_VkTextureLODGatherFormatPropertiesAMD::operator=(const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
supportsTextureGatherLODBiasAMD = copy_src.supportsTextureGatherLODBiasAMD;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkTextureLODGatherFormatPropertiesAMD::~safe_VkTextureLODGatherFormatPropertiesAMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct)
{
sType = in_struct->sType;
supportsTextureGatherLODBiasAMD = in_struct->supportsTextureGatherLODBiasAMD;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* copy_src)
{
sType = copy_src->sType;
supportsTextureGatherLODBiasAMD = copy_src->supportsTextureGatherLODBiasAMD;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_GGP
safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
streamDescriptor(in_struct->streamDescriptor)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP() :
sType(VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP),
pNext(nullptr)
{}
safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
streamDescriptor = copy_src.streamDescriptor;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkStreamDescriptorSurfaceCreateInfoGGP& safe_VkStreamDescriptorSurfaceCreateInfoGGP::operator=(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
streamDescriptor = copy_src.streamDescriptor;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkStreamDescriptorSurfaceCreateInfoGGP::~safe_VkStreamDescriptorSurfaceCreateInfoGGP()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkStreamDescriptorSurfaceCreateInfoGGP::initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
streamDescriptor = in_struct->streamDescriptor;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkStreamDescriptorSurfaceCreateInfoGGP::initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
streamDescriptor = copy_src->streamDescriptor;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_GGP
safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct) :
sType(in_struct->sType),
cornerSampledImage(in_struct->cornerSampledImage)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src)
{
sType = copy_src.sType;
cornerSampledImage = copy_src.cornerSampledImage;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::operator=(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
cornerSampledImage = copy_src.cornerSampledImage;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct)
{
sType = in_struct->sType;
cornerSampledImage = in_struct->cornerSampledImage;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::initialize(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* copy_src)
{
sType = copy_src->sType;
cornerSampledImage = copy_src->cornerSampledImage;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct) :
sType(in_struct->sType),
handleTypes(in_struct->handleTypes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& copy_src)
{
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalMemoryImageCreateInfoNV& safe_VkExternalMemoryImageCreateInfoNV::operator=(const safe_VkExternalMemoryImageCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalMemoryImageCreateInfoNV::~safe_VkExternalMemoryImageCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExternalMemoryImageCreateInfoNV::initialize(const VkExternalMemoryImageCreateInfoNV* in_struct)
{
sType = in_struct->sType;
handleTypes = in_struct->handleTypes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExternalMemoryImageCreateInfoNV::initialize(const safe_VkExternalMemoryImageCreateInfoNV* copy_src)
{
sType = copy_src->sType;
handleTypes = copy_src->handleTypes;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct) :
sType(in_struct->sType),
handleTypes(in_struct->handleTypes)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV() :
sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV),
pNext(nullptr)
{}
safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& copy_src)
{
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExportMemoryAllocateInfoNV& safe_VkExportMemoryAllocateInfoNV::operator=(const safe_VkExportMemoryAllocateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleTypes = copy_src.handleTypes;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExportMemoryAllocateInfoNV::~safe_VkExportMemoryAllocateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExportMemoryAllocateInfoNV::initialize(const VkExportMemoryAllocateInfoNV* in_struct)
{
sType = in_struct->sType;
handleTypes = in_struct->handleTypes;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExportMemoryAllocateInfoNV::initialize(const safe_VkExportMemoryAllocateInfoNV* copy_src)
{
sType = copy_src->sType;
handleTypes = copy_src->handleTypes;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct) :
sType(in_struct->sType),
handleType(in_struct->handleType),
handle(in_struct->handle)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV() :
sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV),
pNext(nullptr)
{}
safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& copy_src)
{
sType = copy_src.sType;
handleType = copy_src.handleType;
handle = copy_src.handle;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportMemoryWin32HandleInfoNV& safe_VkImportMemoryWin32HandleInfoNV::operator=(const safe_VkImportMemoryWin32HandleInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleType = copy_src.handleType;
handle = copy_src.handle;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportMemoryWin32HandleInfoNV::~safe_VkImportMemoryWin32HandleInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportMemoryWin32HandleInfoNV::initialize(const VkImportMemoryWin32HandleInfoNV* in_struct)
{
sType = in_struct->sType;
handleType = in_struct->handleType;
handle = in_struct->handle;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportMemoryWin32HandleInfoNV::initialize(const safe_VkImportMemoryWin32HandleInfoNV* copy_src)
{
sType = copy_src->sType;
handleType = copy_src->handleType;
handle = copy_src->handle;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct) :
sType(in_struct->sType),
pAttributes(nullptr),
dwAccess(in_struct->dwAccess)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
}
}
safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV() :
sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV),
pNext(nullptr),
pAttributes(nullptr)
{}
safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& copy_src)
{
sType = copy_src.sType;
pAttributes = nullptr;
dwAccess = copy_src.dwAccess;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
}
}
safe_VkExportMemoryWin32HandleInfoNV& safe_VkExportMemoryWin32HandleInfoNV::operator=(const safe_VkExportMemoryWin32HandleInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pAttributes)
delete pAttributes;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pAttributes = nullptr;
dwAccess = copy_src.dwAccess;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
}
return *this;
}
safe_VkExportMemoryWin32HandleInfoNV::~safe_VkExportMemoryWin32HandleInfoNV()
{
if (pAttributes)
delete pAttributes;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExportMemoryWin32HandleInfoNV::initialize(const VkExportMemoryWin32HandleInfoNV* in_struct)
{
sType = in_struct->sType;
pAttributes = nullptr;
dwAccess = in_struct->dwAccess;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
}
}
void safe_VkExportMemoryWin32HandleInfoNV::initialize(const safe_VkExportMemoryWin32HandleInfoNV* copy_src)
{
sType = copy_src->sType;
pAttributes = nullptr;
dwAccess = copy_src->dwAccess;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pAttributes) {
pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
}
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct) :
sType(in_struct->sType),
acquireCount(in_struct->acquireCount),
pAcquireSyncs(nullptr),
pAcquireKeys(nullptr),
pAcquireTimeoutMilliseconds(nullptr),
releaseCount(in_struct->releaseCount),
pReleaseSyncs(nullptr),
pReleaseKeys(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (acquireCount && in_struct->pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
}
}
if (in_struct->pAcquireKeys) {
pAcquireKeys = new uint64_t[in_struct->acquireCount];
memcpy ((void *)pAcquireKeys, (void *)in_struct->pAcquireKeys, sizeof(uint64_t)*in_struct->acquireCount);
}
if (in_struct->pAcquireTimeoutMilliseconds) {
pAcquireTimeoutMilliseconds = new uint32_t[in_struct->acquireCount];
memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)in_struct->pAcquireTimeoutMilliseconds, sizeof(uint32_t)*in_struct->acquireCount);
}
if (releaseCount && in_struct->pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
}
}
if (in_struct->pReleaseKeys) {
pReleaseKeys = new uint64_t[in_struct->releaseCount];
memcpy ((void *)pReleaseKeys, (void *)in_struct->pReleaseKeys, sizeof(uint64_t)*in_struct->releaseCount);
}
}
safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV() :
sType(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV),
pNext(nullptr),
pAcquireSyncs(nullptr),
pAcquireKeys(nullptr),
pAcquireTimeoutMilliseconds(nullptr),
pReleaseSyncs(nullptr),
pReleaseKeys(nullptr)
{}
safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src)
{
sType = copy_src.sType;
acquireCount = copy_src.acquireCount;
pAcquireSyncs = nullptr;
pAcquireKeys = nullptr;
pAcquireTimeoutMilliseconds = nullptr;
releaseCount = copy_src.releaseCount;
pReleaseSyncs = nullptr;
pReleaseKeys = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (acquireCount && copy_src.pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
}
}
if (copy_src.pAcquireKeys) {
pAcquireKeys = new uint64_t[copy_src.acquireCount];
memcpy ((void *)pAcquireKeys, (void *)copy_src.pAcquireKeys, sizeof(uint64_t)*copy_src.acquireCount);
}
if (copy_src.pAcquireTimeoutMilliseconds) {
pAcquireTimeoutMilliseconds = new uint32_t[copy_src.acquireCount];
memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)copy_src.pAcquireTimeoutMilliseconds, sizeof(uint32_t)*copy_src.acquireCount);
}
if (releaseCount && copy_src.pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
}
}
if (copy_src.pReleaseKeys) {
pReleaseKeys = new uint64_t[copy_src.releaseCount];
memcpy ((void *)pReleaseKeys, (void *)copy_src.pReleaseKeys, sizeof(uint64_t)*copy_src.releaseCount);
}
}
safe_VkWin32KeyedMutexAcquireReleaseInfoNV& safe_VkWin32KeyedMutexAcquireReleaseInfoNV::operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pAcquireSyncs)
delete[] pAcquireSyncs;
if (pAcquireKeys)
delete[] pAcquireKeys;
if (pAcquireTimeoutMilliseconds)
delete[] pAcquireTimeoutMilliseconds;
if (pReleaseSyncs)
delete[] pReleaseSyncs;
if (pReleaseKeys)
delete[] pReleaseKeys;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
acquireCount = copy_src.acquireCount;
pAcquireSyncs = nullptr;
pAcquireKeys = nullptr;
pAcquireTimeoutMilliseconds = nullptr;
releaseCount = copy_src.releaseCount;
pReleaseSyncs = nullptr;
pReleaseKeys = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (acquireCount && copy_src.pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
}
}
if (copy_src.pAcquireKeys) {
pAcquireKeys = new uint64_t[copy_src.acquireCount];
memcpy ((void *)pAcquireKeys, (void *)copy_src.pAcquireKeys, sizeof(uint64_t)*copy_src.acquireCount);
}
if (copy_src.pAcquireTimeoutMilliseconds) {
pAcquireTimeoutMilliseconds = new uint32_t[copy_src.acquireCount];
memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)copy_src.pAcquireTimeoutMilliseconds, sizeof(uint32_t)*copy_src.acquireCount);
}
if (releaseCount && copy_src.pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
}
}
if (copy_src.pReleaseKeys) {
pReleaseKeys = new uint64_t[copy_src.releaseCount];
memcpy ((void *)pReleaseKeys, (void *)copy_src.pReleaseKeys, sizeof(uint64_t)*copy_src.releaseCount);
}
return *this;
}
safe_VkWin32KeyedMutexAcquireReleaseInfoNV::~safe_VkWin32KeyedMutexAcquireReleaseInfoNV()
{
if (pAcquireSyncs)
delete[] pAcquireSyncs;
if (pAcquireKeys)
delete[] pAcquireKeys;
if (pAcquireTimeoutMilliseconds)
delete[] pAcquireTimeoutMilliseconds;
if (pReleaseSyncs)
delete[] pReleaseSyncs;
if (pReleaseKeys)
delete[] pReleaseKeys;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct)
{
sType = in_struct->sType;
acquireCount = in_struct->acquireCount;
pAcquireSyncs = nullptr;
pAcquireKeys = nullptr;
pAcquireTimeoutMilliseconds = nullptr;
releaseCount = in_struct->releaseCount;
pReleaseSyncs = nullptr;
pReleaseKeys = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (acquireCount && in_struct->pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
}
}
if (in_struct->pAcquireKeys) {
pAcquireKeys = new uint64_t[in_struct->acquireCount];
memcpy ((void *)pAcquireKeys, (void *)in_struct->pAcquireKeys, sizeof(uint64_t)*in_struct->acquireCount);
}
if (in_struct->pAcquireTimeoutMilliseconds) {
pAcquireTimeoutMilliseconds = new uint32_t[in_struct->acquireCount];
memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)in_struct->pAcquireTimeoutMilliseconds, sizeof(uint32_t)*in_struct->acquireCount);
}
if (releaseCount && in_struct->pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
}
}
if (in_struct->pReleaseKeys) {
pReleaseKeys = new uint64_t[in_struct->releaseCount];
memcpy ((void *)pReleaseKeys, (void *)in_struct->pReleaseKeys, sizeof(uint64_t)*in_struct->releaseCount);
}
}
void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* copy_src)
{
sType = copy_src->sType;
acquireCount = copy_src->acquireCount;
pAcquireSyncs = nullptr;
pAcquireKeys = nullptr;
pAcquireTimeoutMilliseconds = nullptr;
releaseCount = copy_src->releaseCount;
pReleaseSyncs = nullptr;
pReleaseKeys = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (acquireCount && copy_src->pAcquireSyncs) {
pAcquireSyncs = new VkDeviceMemory[acquireCount];
for (uint32_t i = 0; i < acquireCount; ++i) {
pAcquireSyncs[i] = copy_src->pAcquireSyncs[i];
}
}
if (copy_src->pAcquireKeys) {
pAcquireKeys = new uint64_t[copy_src->acquireCount];
memcpy ((void *)pAcquireKeys, (void *)copy_src->pAcquireKeys, sizeof(uint64_t)*copy_src->acquireCount);
}
if (copy_src->pAcquireTimeoutMilliseconds) {
pAcquireTimeoutMilliseconds = new uint32_t[copy_src->acquireCount];
memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)copy_src->pAcquireTimeoutMilliseconds, sizeof(uint32_t)*copy_src->acquireCount);
}
if (releaseCount && copy_src->pReleaseSyncs) {
pReleaseSyncs = new VkDeviceMemory[releaseCount];
for (uint32_t i = 0; i < releaseCount; ++i) {
pReleaseSyncs[i] = copy_src->pReleaseSyncs[i];
}
}
if (copy_src->pReleaseKeys) {
pReleaseKeys = new uint64_t[copy_src->releaseCount];
memcpy ((void *)pReleaseKeys, (void *)copy_src->pReleaseKeys, sizeof(uint64_t)*copy_src->releaseCount);
}
}
#endif // VK_USE_PLATFORM_WIN32_KHR
safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct) :
sType(in_struct->sType),
disabledValidationCheckCount(in_struct->disabledValidationCheckCount),
pDisabledValidationChecks(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDisabledValidationChecks) {
pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount];
memcpy ((void *)pDisabledValidationChecks, (void *)in_struct->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*in_struct->disabledValidationCheckCount);
}
}
safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT() :
sType(VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT),
pNext(nullptr),
pDisabledValidationChecks(nullptr)
{}
safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& copy_src)
{
sType = copy_src.sType;
disabledValidationCheckCount = copy_src.disabledValidationCheckCount;
pDisabledValidationChecks = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDisabledValidationChecks) {
pDisabledValidationChecks = new VkValidationCheckEXT[copy_src.disabledValidationCheckCount];
memcpy ((void *)pDisabledValidationChecks, (void *)copy_src.pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*copy_src.disabledValidationCheckCount);
}
}
safe_VkValidationFlagsEXT& safe_VkValidationFlagsEXT::operator=(const safe_VkValidationFlagsEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pDisabledValidationChecks)
delete[] pDisabledValidationChecks;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
disabledValidationCheckCount = copy_src.disabledValidationCheckCount;
pDisabledValidationChecks = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDisabledValidationChecks) {
pDisabledValidationChecks = new VkValidationCheckEXT[copy_src.disabledValidationCheckCount];
memcpy ((void *)pDisabledValidationChecks, (void *)copy_src.pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*copy_src.disabledValidationCheckCount);
}
return *this;
}
safe_VkValidationFlagsEXT::~safe_VkValidationFlagsEXT()
{
if (pDisabledValidationChecks)
delete[] pDisabledValidationChecks;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkValidationFlagsEXT::initialize(const VkValidationFlagsEXT* in_struct)
{
sType = in_struct->sType;
disabledValidationCheckCount = in_struct->disabledValidationCheckCount;
pDisabledValidationChecks = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDisabledValidationChecks) {
pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount];
memcpy ((void *)pDisabledValidationChecks, (void *)in_struct->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*in_struct->disabledValidationCheckCount);
}
}
void safe_VkValidationFlagsEXT::initialize(const safe_VkValidationFlagsEXT* copy_src)
{
sType = copy_src->sType;
disabledValidationCheckCount = copy_src->disabledValidationCheckCount;
pDisabledValidationChecks = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDisabledValidationChecks) {
pDisabledValidationChecks = new VkValidationCheckEXT[copy_src->disabledValidationCheckCount];
memcpy ((void *)pDisabledValidationChecks, (void *)copy_src->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*copy_src->disabledValidationCheckCount);
}
}
#ifdef VK_USE_PLATFORM_VI_NN
safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
window(in_struct->window)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN() :
sType(VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN),
pNext(nullptr),
window(nullptr)
{}
safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
window = copy_src.window;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkViSurfaceCreateInfoNN& safe_VkViSurfaceCreateInfoNN::operator=(const safe_VkViSurfaceCreateInfoNN& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
window = copy_src.window;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkViSurfaceCreateInfoNN::~safe_VkViSurfaceCreateInfoNN()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkViSurfaceCreateInfoNN::initialize(const VkViSurfaceCreateInfoNN* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
window = in_struct->window;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkViSurfaceCreateInfoNN::initialize(const safe_VkViSurfaceCreateInfoNN* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
window = copy_src->window;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_VI_NN
safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct) :
sType(in_struct->sType),
textureCompressionASTC_HDR(in_struct->textureCompressionASTC_HDR)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& copy_src)
{
sType = copy_src.sType;
textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::operator=(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct)
{
sType = in_struct->sType;
textureCompressionASTC_HDR = in_struct->textureCompressionASTC_HDR;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::initialize(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* copy_src)
{
sType = copy_src->sType;
textureCompressionASTC_HDR = copy_src->textureCompressionASTC_HDR;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct) :
sType(in_struct->sType),
decodeMode(in_struct->decodeMode)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT() :
sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT),
pNext(nullptr)
{}
safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& copy_src)
{
sType = copy_src.sType;
decodeMode = copy_src.decodeMode;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageViewASTCDecodeModeEXT& safe_VkImageViewASTCDecodeModeEXT::operator=(const safe_VkImageViewASTCDecodeModeEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
decodeMode = copy_src.decodeMode;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageViewASTCDecodeModeEXT::~safe_VkImageViewASTCDecodeModeEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageViewASTCDecodeModeEXT::initialize(const VkImageViewASTCDecodeModeEXT* in_struct)
{
sType = in_struct->sType;
decodeMode = in_struct->decodeMode;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageViewASTCDecodeModeEXT::initialize(const safe_VkImageViewASTCDecodeModeEXT* copy_src)
{
sType = copy_src->sType;
decodeMode = copy_src->decodeMode;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct) :
sType(in_struct->sType),
decodeModeSharedExponent(in_struct->decodeModeSharedExponent)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src)
{
sType = copy_src.sType;
decodeModeSharedExponent = copy_src.decodeModeSharedExponent;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::operator=(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
decodeModeSharedExponent = copy_src.decodeModeSharedExponent;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct)
{
sType = in_struct->sType;
decodeModeSharedExponent = in_struct->decodeModeSharedExponent;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* copy_src)
{
sType = copy_src->sType;
decodeModeSharedExponent = copy_src->decodeModeSharedExponent;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* in_struct) :
sType(in_struct->sType),
buffer(in_struct->buffer),
offset(in_struct->offset),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT() :
sType(VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT),
pNext(nullptr)
{}
safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT(const safe_VkConditionalRenderingBeginInfoEXT& copy_src)
{
sType = copy_src.sType;
buffer = copy_src.buffer;
offset = copy_src.offset;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkConditionalRenderingBeginInfoEXT& safe_VkConditionalRenderingBeginInfoEXT::operator=(const safe_VkConditionalRenderingBeginInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
buffer = copy_src.buffer;
offset = copy_src.offset;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkConditionalRenderingBeginInfoEXT::~safe_VkConditionalRenderingBeginInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkConditionalRenderingBeginInfoEXT::initialize(const VkConditionalRenderingBeginInfoEXT* in_struct)
{
sType = in_struct->sType;
buffer = in_struct->buffer;
offset = in_struct->offset;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkConditionalRenderingBeginInfoEXT::initialize(const safe_VkConditionalRenderingBeginInfoEXT* copy_src)
{
sType = copy_src->sType;
buffer = copy_src->buffer;
offset = copy_src->offset;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct) :
sType(in_struct->sType),
conditionalRendering(in_struct->conditionalRendering),
inheritedConditionalRendering(in_struct->inheritedConditionalRendering)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src)
{
sType = copy_src.sType;
conditionalRendering = copy_src.conditionalRendering;
inheritedConditionalRendering = copy_src.inheritedConditionalRendering;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::operator=(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
conditionalRendering = copy_src.conditionalRendering;
inheritedConditionalRendering = copy_src.inheritedConditionalRendering;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::initialize(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct)
{
sType = in_struct->sType;
conditionalRendering = in_struct->conditionalRendering;
inheritedConditionalRendering = in_struct->inheritedConditionalRendering;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::initialize(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* copy_src)
{
sType = copy_src->sType;
conditionalRendering = copy_src->conditionalRendering;
inheritedConditionalRendering = copy_src->inheritedConditionalRendering;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct) :
sType(in_struct->sType),
conditionalRenderingEnable(in_struct->conditionalRenderingEnable)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT() :
sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT),
pNext(nullptr)
{}
safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src)
{
sType = copy_src.sType;
conditionalRenderingEnable = copy_src.conditionalRenderingEnable;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::operator=(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
conditionalRenderingEnable = copy_src.conditionalRenderingEnable;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::initialize(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct)
{
sType = in_struct->sType;
conditionalRenderingEnable = in_struct->conditionalRenderingEnable;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::initialize(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* copy_src)
{
sType = copy_src->sType;
conditionalRenderingEnable = copy_src->conditionalRenderingEnable;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
viewportWScalingEnable(in_struct->viewportWScalingEnable),
viewportCount(in_struct->viewportCount),
pViewportWScalings(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewportWScalings) {
pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount];
memcpy ((void *)pViewportWScalings, (void *)in_struct->pViewportWScalings, sizeof(VkViewportWScalingNV)*in_struct->viewportCount);
}
}
safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV),
pNext(nullptr),
pViewportWScalings(nullptr)
{}
safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
viewportWScalingEnable = copy_src.viewportWScalingEnable;
viewportCount = copy_src.viewportCount;
pViewportWScalings = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewportWScalings) {
pViewportWScalings = new VkViewportWScalingNV[copy_src.viewportCount];
memcpy ((void *)pViewportWScalings, (void *)copy_src.pViewportWScalings, sizeof(VkViewportWScalingNV)*copy_src.viewportCount);
}
}
safe_VkPipelineViewportWScalingStateCreateInfoNV& safe_VkPipelineViewportWScalingStateCreateInfoNV::operator=(const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pViewportWScalings)
delete[] pViewportWScalings;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
viewportWScalingEnable = copy_src.viewportWScalingEnable;
viewportCount = copy_src.viewportCount;
pViewportWScalings = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewportWScalings) {
pViewportWScalings = new VkViewportWScalingNV[copy_src.viewportCount];
memcpy ((void *)pViewportWScalings, (void *)copy_src.pViewportWScalings, sizeof(VkViewportWScalingNV)*copy_src.viewportCount);
}
return *this;
}
safe_VkPipelineViewportWScalingStateCreateInfoNV::~safe_VkPipelineViewportWScalingStateCreateInfoNV()
{
if (pViewportWScalings)
delete[] pViewportWScalings;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
viewportWScalingEnable = in_struct->viewportWScalingEnable;
viewportCount = in_struct->viewportCount;
pViewportWScalings = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewportWScalings) {
pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount];
memcpy ((void *)pViewportWScalings, (void *)in_struct->pViewportWScalings, sizeof(VkViewportWScalingNV)*in_struct->viewportCount);
}
}
void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
viewportWScalingEnable = copy_src->viewportWScalingEnable;
viewportCount = copy_src->viewportCount;
pViewportWScalings = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pViewportWScalings) {
pViewportWScalings = new VkViewportWScalingNV[copy_src->viewportCount];
memcpy ((void *)pViewportWScalings, (void *)copy_src->pViewportWScalings, sizeof(VkViewportWScalingNV)*copy_src->viewportCount);
}
}
safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct) :
sType(in_struct->sType),
minImageCount(in_struct->minImageCount),
maxImageCount(in_struct->maxImageCount),
currentExtent(in_struct->currentExtent),
minImageExtent(in_struct->minImageExtent),
maxImageExtent(in_struct->maxImageExtent),
maxImageArrayLayers(in_struct->maxImageArrayLayers),
supportedTransforms(in_struct->supportedTransforms),
currentTransform(in_struct->currentTransform),
supportedCompositeAlpha(in_struct->supportedCompositeAlpha),
supportedUsageFlags(in_struct->supportedUsageFlags),
supportedSurfaceCounters(in_struct->supportedSurfaceCounters)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT() :
sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT),
pNext(nullptr)
{}
safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& copy_src)
{
sType = copy_src.sType;
minImageCount = copy_src.minImageCount;
maxImageCount = copy_src.maxImageCount;
currentExtent = copy_src.currentExtent;
minImageExtent = copy_src.minImageExtent;
maxImageExtent = copy_src.maxImageExtent;
maxImageArrayLayers = copy_src.maxImageArrayLayers;
supportedTransforms = copy_src.supportedTransforms;
currentTransform = copy_src.currentTransform;
supportedCompositeAlpha = copy_src.supportedCompositeAlpha;
supportedUsageFlags = copy_src.supportedUsageFlags;
supportedSurfaceCounters = copy_src.supportedSurfaceCounters;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSurfaceCapabilities2EXT& safe_VkSurfaceCapabilities2EXT::operator=(const safe_VkSurfaceCapabilities2EXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
minImageCount = copy_src.minImageCount;
maxImageCount = copy_src.maxImageCount;
currentExtent = copy_src.currentExtent;
minImageExtent = copy_src.minImageExtent;
maxImageExtent = copy_src.maxImageExtent;
maxImageArrayLayers = copy_src.maxImageArrayLayers;
supportedTransforms = copy_src.supportedTransforms;
currentTransform = copy_src.currentTransform;
supportedCompositeAlpha = copy_src.supportedCompositeAlpha;
supportedUsageFlags = copy_src.supportedUsageFlags;
supportedSurfaceCounters = copy_src.supportedSurfaceCounters;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSurfaceCapabilities2EXT::~safe_VkSurfaceCapabilities2EXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSurfaceCapabilities2EXT::initialize(const VkSurfaceCapabilities2EXT* in_struct)
{
sType = in_struct->sType;
minImageCount = in_struct->minImageCount;
maxImageCount = in_struct->maxImageCount;
currentExtent = in_struct->currentExtent;
minImageExtent = in_struct->minImageExtent;
maxImageExtent = in_struct->maxImageExtent;
maxImageArrayLayers = in_struct->maxImageArrayLayers;
supportedTransforms = in_struct->supportedTransforms;
currentTransform = in_struct->currentTransform;
supportedCompositeAlpha = in_struct->supportedCompositeAlpha;
supportedUsageFlags = in_struct->supportedUsageFlags;
supportedSurfaceCounters = in_struct->supportedSurfaceCounters;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSurfaceCapabilities2EXT::initialize(const safe_VkSurfaceCapabilities2EXT* copy_src)
{
sType = copy_src->sType;
minImageCount = copy_src->minImageCount;
maxImageCount = copy_src->maxImageCount;
currentExtent = copy_src->currentExtent;
minImageExtent = copy_src->minImageExtent;
maxImageExtent = copy_src->maxImageExtent;
maxImageArrayLayers = copy_src->maxImageArrayLayers;
supportedTransforms = copy_src->supportedTransforms;
currentTransform = copy_src->currentTransform;
supportedCompositeAlpha = copy_src->supportedCompositeAlpha;
supportedUsageFlags = copy_src->supportedUsageFlags;
supportedSurfaceCounters = copy_src->supportedSurfaceCounters;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct) :
sType(in_struct->sType),
powerState(in_struct->powerState)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT() :
sType(VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT),
pNext(nullptr)
{}
safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& copy_src)
{
sType = copy_src.sType;
powerState = copy_src.powerState;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayPowerInfoEXT& safe_VkDisplayPowerInfoEXT::operator=(const safe_VkDisplayPowerInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
powerState = copy_src.powerState;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayPowerInfoEXT::~safe_VkDisplayPowerInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayPowerInfoEXT::initialize(const VkDisplayPowerInfoEXT* in_struct)
{
sType = in_struct->sType;
powerState = in_struct->powerState;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayPowerInfoEXT::initialize(const safe_VkDisplayPowerInfoEXT* copy_src)
{
sType = copy_src->sType;
powerState = copy_src->powerState;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct) :
sType(in_struct->sType),
deviceEvent(in_struct->deviceEvent)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT),
pNext(nullptr)
{}
safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& copy_src)
{
sType = copy_src.sType;
deviceEvent = copy_src.deviceEvent;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceEventInfoEXT& safe_VkDeviceEventInfoEXT::operator=(const safe_VkDeviceEventInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceEvent = copy_src.deviceEvent;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceEventInfoEXT::~safe_VkDeviceEventInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceEventInfoEXT::initialize(const VkDeviceEventInfoEXT* in_struct)
{
sType = in_struct->sType;
deviceEvent = in_struct->deviceEvent;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceEventInfoEXT::initialize(const safe_VkDeviceEventInfoEXT* copy_src)
{
sType = copy_src->sType;
deviceEvent = copy_src->deviceEvent;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct) :
sType(in_struct->sType),
displayEvent(in_struct->displayEvent)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT() :
sType(VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT),
pNext(nullptr)
{}
safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& copy_src)
{
sType = copy_src.sType;
displayEvent = copy_src.displayEvent;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayEventInfoEXT& safe_VkDisplayEventInfoEXT::operator=(const safe_VkDisplayEventInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
displayEvent = copy_src.displayEvent;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayEventInfoEXT::~safe_VkDisplayEventInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayEventInfoEXT::initialize(const VkDisplayEventInfoEXT* in_struct)
{
sType = in_struct->sType;
displayEvent = in_struct->displayEvent;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayEventInfoEXT::initialize(const safe_VkDisplayEventInfoEXT* copy_src)
{
sType = copy_src->sType;
displayEvent = copy_src->displayEvent;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct) :
sType(in_struct->sType),
surfaceCounters(in_struct->surfaceCounters)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
surfaceCounters = copy_src.surfaceCounters;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSwapchainCounterCreateInfoEXT& safe_VkSwapchainCounterCreateInfoEXT::operator=(const safe_VkSwapchainCounterCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
surfaceCounters = copy_src.surfaceCounters;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSwapchainCounterCreateInfoEXT::~safe_VkSwapchainCounterCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSwapchainCounterCreateInfoEXT::initialize(const VkSwapchainCounterCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
surfaceCounters = in_struct->surfaceCounters;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSwapchainCounterCreateInfoEXT::initialize(const safe_VkSwapchainCounterCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
surfaceCounters = copy_src->surfaceCounters;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct) :
sType(in_struct->sType),
swapchainCount(in_struct->swapchainCount),
pTimes(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pTimes) {
pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount];
memcpy ((void *)pTimes, (void *)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE)*in_struct->swapchainCount);
}
}
safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE() :
sType(VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE),
pNext(nullptr),
pTimes(nullptr)
{}
safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& copy_src)
{
sType = copy_src.sType;
swapchainCount = copy_src.swapchainCount;
pTimes = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pTimes) {
pTimes = new VkPresentTimeGOOGLE[copy_src.swapchainCount];
memcpy ((void *)pTimes, (void *)copy_src.pTimes, sizeof(VkPresentTimeGOOGLE)*copy_src.swapchainCount);
}
}
safe_VkPresentTimesInfoGOOGLE& safe_VkPresentTimesInfoGOOGLE::operator=(const safe_VkPresentTimesInfoGOOGLE& copy_src)
{
if (&copy_src == this) return *this;
if (pTimes)
delete[] pTimes;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
swapchainCount = copy_src.swapchainCount;
pTimes = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pTimes) {
pTimes = new VkPresentTimeGOOGLE[copy_src.swapchainCount];
memcpy ((void *)pTimes, (void *)copy_src.pTimes, sizeof(VkPresentTimeGOOGLE)*copy_src.swapchainCount);
}
return *this;
}
safe_VkPresentTimesInfoGOOGLE::~safe_VkPresentTimesInfoGOOGLE()
{
if (pTimes)
delete[] pTimes;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPresentTimesInfoGOOGLE::initialize(const VkPresentTimesInfoGOOGLE* in_struct)
{
sType = in_struct->sType;
swapchainCount = in_struct->swapchainCount;
pTimes = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pTimes) {
pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount];
memcpy ((void *)pTimes, (void *)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE)*in_struct->swapchainCount);
}
}
void safe_VkPresentTimesInfoGOOGLE::initialize(const safe_VkPresentTimesInfoGOOGLE* copy_src)
{
sType = copy_src->sType;
swapchainCount = copy_src->swapchainCount;
pTimes = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pTimes) {
pTimes = new VkPresentTimeGOOGLE[copy_src->swapchainCount];
memcpy ((void *)pTimes, (void *)copy_src->pTimes, sizeof(VkPresentTimeGOOGLE)*copy_src->swapchainCount);
}
}
safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct) :
sType(in_struct->sType),
perViewPositionAllComponents(in_struct->perViewPositionAllComponents)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src)
{
sType = copy_src.sType;
perViewPositionAllComponents = copy_src.perViewPositionAllComponents;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
perViewPositionAllComponents = copy_src.perViewPositionAllComponents;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct)
{
sType = in_struct->sType;
perViewPositionAllComponents = in_struct->perViewPositionAllComponents;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* copy_src)
{
sType = copy_src->sType;
perViewPositionAllComponents = copy_src->perViewPositionAllComponents;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
viewportCount(in_struct->viewportCount),
pViewportSwizzles(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewportSwizzles) {
pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount];
memcpy ((void *)pViewportSwizzles, (void *)in_struct->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*in_struct->viewportCount);
}
}
safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV),
pNext(nullptr),
pViewportSwizzles(nullptr)
{}
safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
viewportCount = copy_src.viewportCount;
pViewportSwizzles = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewportSwizzles) {
pViewportSwizzles = new VkViewportSwizzleNV[copy_src.viewportCount];
memcpy ((void *)pViewportSwizzles, (void *)copy_src.pViewportSwizzles, sizeof(VkViewportSwizzleNV)*copy_src.viewportCount);
}
}
safe_VkPipelineViewportSwizzleStateCreateInfoNV& safe_VkPipelineViewportSwizzleStateCreateInfoNV::operator=(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pViewportSwizzles)
delete[] pViewportSwizzles;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
viewportCount = copy_src.viewportCount;
pViewportSwizzles = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewportSwizzles) {
pViewportSwizzles = new VkViewportSwizzleNV[copy_src.viewportCount];
memcpy ((void *)pViewportSwizzles, (void *)copy_src.pViewportSwizzles, sizeof(VkViewportSwizzleNV)*copy_src.viewportCount);
}
return *this;
}
safe_VkPipelineViewportSwizzleStateCreateInfoNV::~safe_VkPipelineViewportSwizzleStateCreateInfoNV()
{
if (pViewportSwizzles)
delete[] pViewportSwizzles;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
viewportCount = in_struct->viewportCount;
pViewportSwizzles = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewportSwizzles) {
pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount];
memcpy ((void *)pViewportSwizzles, (void *)in_struct->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*in_struct->viewportCount);
}
}
void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
viewportCount = copy_src->viewportCount;
pViewportSwizzles = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pViewportSwizzles) {
pViewportSwizzles = new VkViewportSwizzleNV[copy_src->viewportCount];
memcpy ((void *)pViewportSwizzles, (void *)copy_src->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*copy_src->viewportCount);
}
}
safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct) :
sType(in_struct->sType),
maxDiscardRectangles(in_struct->maxDiscardRectangles)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src)
{
sType = copy_src.sType;
maxDiscardRectangles = copy_src.maxDiscardRectangles;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::operator=(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxDiscardRectangles = copy_src.maxDiscardRectangles;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct)
{
sType = in_struct->sType;
maxDiscardRectangles = in_struct->maxDiscardRectangles;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* copy_src)
{
sType = copy_src->sType;
maxDiscardRectangles = copy_src->maxDiscardRectangles;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
discardRectangleMode(in_struct->discardRectangleMode),
discardRectangleCount(in_struct->discardRectangleCount),
pDiscardRectangles(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDiscardRectangles) {
pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount];
memcpy ((void *)pDiscardRectangles, (void *)in_struct->pDiscardRectangles, sizeof(VkRect2D)*in_struct->discardRectangleCount);
}
}
safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT),
pNext(nullptr),
pDiscardRectangles(nullptr)
{}
safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
discardRectangleMode = copy_src.discardRectangleMode;
discardRectangleCount = copy_src.discardRectangleCount;
pDiscardRectangles = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDiscardRectangles) {
pDiscardRectangles = new VkRect2D[copy_src.discardRectangleCount];
memcpy ((void *)pDiscardRectangles, (void *)copy_src.pDiscardRectangles, sizeof(VkRect2D)*copy_src.discardRectangleCount);
}
}
safe_VkPipelineDiscardRectangleStateCreateInfoEXT& safe_VkPipelineDiscardRectangleStateCreateInfoEXT::operator=(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pDiscardRectangles)
delete[] pDiscardRectangles;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
discardRectangleMode = copy_src.discardRectangleMode;
discardRectangleCount = copy_src.discardRectangleCount;
pDiscardRectangles = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDiscardRectangles) {
pDiscardRectangles = new VkRect2D[copy_src.discardRectangleCount];
memcpy ((void *)pDiscardRectangles, (void *)copy_src.pDiscardRectangles, sizeof(VkRect2D)*copy_src.discardRectangleCount);
}
return *this;
}
safe_VkPipelineDiscardRectangleStateCreateInfoEXT::~safe_VkPipelineDiscardRectangleStateCreateInfoEXT()
{
if (pDiscardRectangles)
delete[] pDiscardRectangles;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
discardRectangleMode = in_struct->discardRectangleMode;
discardRectangleCount = in_struct->discardRectangleCount;
pDiscardRectangles = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDiscardRectangles) {
pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount];
memcpy ((void *)pDiscardRectangles, (void *)in_struct->pDiscardRectangles, sizeof(VkRect2D)*in_struct->discardRectangleCount);
}
}
void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
discardRectangleMode = copy_src->discardRectangleMode;
discardRectangleCount = copy_src->discardRectangleCount;
pDiscardRectangles = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDiscardRectangles) {
pDiscardRectangles = new VkRect2D[copy_src->discardRectangleCount];
memcpy ((void *)pDiscardRectangles, (void *)copy_src->pDiscardRectangles, sizeof(VkRect2D)*copy_src->discardRectangleCount);
}
}
safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct) :
sType(in_struct->sType),
primitiveOverestimationSize(in_struct->primitiveOverestimationSize),
maxExtraPrimitiveOverestimationSize(in_struct->maxExtraPrimitiveOverestimationSize),
extraPrimitiveOverestimationSizeGranularity(in_struct->extraPrimitiveOverestimationSizeGranularity),
primitiveUnderestimation(in_struct->primitiveUnderestimation),
conservativePointAndLineRasterization(in_struct->conservativePointAndLineRasterization),
degenerateTrianglesRasterized(in_struct->degenerateTrianglesRasterized),
degenerateLinesRasterized(in_struct->degenerateLinesRasterized),
fullyCoveredFragmentShaderInputVariable(in_struct->fullyCoveredFragmentShaderInputVariable),
conservativeRasterizationPostDepthCoverage(in_struct->conservativeRasterizationPostDepthCoverage)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src)
{
sType = copy_src.sType;
primitiveOverestimationSize = copy_src.primitiveOverestimationSize;
maxExtraPrimitiveOverestimationSize = copy_src.maxExtraPrimitiveOverestimationSize;
extraPrimitiveOverestimationSizeGranularity = copy_src.extraPrimitiveOverestimationSizeGranularity;
primitiveUnderestimation = copy_src.primitiveUnderestimation;
conservativePointAndLineRasterization = copy_src.conservativePointAndLineRasterization;
degenerateTrianglesRasterized = copy_src.degenerateTrianglesRasterized;
degenerateLinesRasterized = copy_src.degenerateLinesRasterized;
fullyCoveredFragmentShaderInputVariable = copy_src.fullyCoveredFragmentShaderInputVariable;
conservativeRasterizationPostDepthCoverage = copy_src.conservativeRasterizationPostDepthCoverage;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::operator=(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
primitiveOverestimationSize = copy_src.primitiveOverestimationSize;
maxExtraPrimitiveOverestimationSize = copy_src.maxExtraPrimitiveOverestimationSize;
extraPrimitiveOverestimationSizeGranularity = copy_src.extraPrimitiveOverestimationSizeGranularity;
primitiveUnderestimation = copy_src.primitiveUnderestimation;
conservativePointAndLineRasterization = copy_src.conservativePointAndLineRasterization;
degenerateTrianglesRasterized = copy_src.degenerateTrianglesRasterized;
degenerateLinesRasterized = copy_src.degenerateLinesRasterized;
fullyCoveredFragmentShaderInputVariable = copy_src.fullyCoveredFragmentShaderInputVariable;
conservativeRasterizationPostDepthCoverage = copy_src.conservativeRasterizationPostDepthCoverage;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct)
{
sType = in_struct->sType;
primitiveOverestimationSize = in_struct->primitiveOverestimationSize;
maxExtraPrimitiveOverestimationSize = in_struct->maxExtraPrimitiveOverestimationSize;
extraPrimitiveOverestimationSizeGranularity = in_struct->extraPrimitiveOverestimationSizeGranularity;
primitiveUnderestimation = in_struct->primitiveUnderestimation;
conservativePointAndLineRasterization = in_struct->conservativePointAndLineRasterization;
degenerateTrianglesRasterized = in_struct->degenerateTrianglesRasterized;
degenerateLinesRasterized = in_struct->degenerateLinesRasterized;
fullyCoveredFragmentShaderInputVariable = in_struct->fullyCoveredFragmentShaderInputVariable;
conservativeRasterizationPostDepthCoverage = in_struct->conservativeRasterizationPostDepthCoverage;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* copy_src)
{
sType = copy_src->sType;
primitiveOverestimationSize = copy_src->primitiveOverestimationSize;
maxExtraPrimitiveOverestimationSize = copy_src->maxExtraPrimitiveOverestimationSize;
extraPrimitiveOverestimationSizeGranularity = copy_src->extraPrimitiveOverestimationSizeGranularity;
primitiveUnderestimation = copy_src->primitiveUnderestimation;
conservativePointAndLineRasterization = copy_src->conservativePointAndLineRasterization;
degenerateTrianglesRasterized = copy_src->degenerateTrianglesRasterized;
degenerateLinesRasterized = copy_src->degenerateLinesRasterized;
fullyCoveredFragmentShaderInputVariable = copy_src->fullyCoveredFragmentShaderInputVariable;
conservativeRasterizationPostDepthCoverage = copy_src->conservativeRasterizationPostDepthCoverage;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
conservativeRasterizationMode(in_struct->conservativeRasterizationMode),
extraPrimitiveOverestimationSize(in_struct->extraPrimitiveOverestimationSize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
conservativeRasterizationMode = copy_src.conservativeRasterizationMode;
extraPrimitiveOverestimationSize = copy_src.extraPrimitiveOverestimationSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::operator=(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
conservativeRasterizationMode = copy_src.conservativeRasterizationMode;
extraPrimitiveOverestimationSize = copy_src.extraPrimitiveOverestimationSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::initialize(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
conservativeRasterizationMode = in_struct->conservativeRasterizationMode;
extraPrimitiveOverestimationSize = in_struct->extraPrimitiveOverestimationSize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::initialize(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
conservativeRasterizationMode = copy_src->conservativeRasterizationMode;
extraPrimitiveOverestimationSize = copy_src->extraPrimitiveOverestimationSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct) :
sType(in_struct->sType),
depthClipEnable(in_struct->depthClipEnable)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src)
{
sType = copy_src.sType;
depthClipEnable = copy_src.depthClipEnable;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::operator=(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
depthClipEnable = copy_src.depthClipEnable;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct)
{
sType = in_struct->sType;
depthClipEnable = in_struct->depthClipEnable;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* copy_src)
{
sType = copy_src->sType;
depthClipEnable = copy_src->depthClipEnable;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
depthClipEnable(in_struct->depthClipEnable)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
depthClipEnable = copy_src.depthClipEnable;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::operator=(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
depthClipEnable = copy_src.depthClipEnable;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::initialize(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
depthClipEnable = in_struct->depthClipEnable;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::initialize(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
depthClipEnable = copy_src->depthClipEnable;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct) :
sType(in_struct->sType),
displayPrimaryRed(in_struct->displayPrimaryRed),
displayPrimaryGreen(in_struct->displayPrimaryGreen),
displayPrimaryBlue(in_struct->displayPrimaryBlue),
whitePoint(in_struct->whitePoint),
maxLuminance(in_struct->maxLuminance),
minLuminance(in_struct->minLuminance),
maxContentLightLevel(in_struct->maxContentLightLevel),
maxFrameAverageLightLevel(in_struct->maxFrameAverageLightLevel)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT() :
sType(VK_STRUCTURE_TYPE_HDR_METADATA_EXT),
pNext(nullptr)
{}
safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& copy_src)
{
sType = copy_src.sType;
displayPrimaryRed = copy_src.displayPrimaryRed;
displayPrimaryGreen = copy_src.displayPrimaryGreen;
displayPrimaryBlue = copy_src.displayPrimaryBlue;
whitePoint = copy_src.whitePoint;
maxLuminance = copy_src.maxLuminance;
minLuminance = copy_src.minLuminance;
maxContentLightLevel = copy_src.maxContentLightLevel;
maxFrameAverageLightLevel = copy_src.maxFrameAverageLightLevel;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkHdrMetadataEXT& safe_VkHdrMetadataEXT::operator=(const safe_VkHdrMetadataEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
displayPrimaryRed = copy_src.displayPrimaryRed;
displayPrimaryGreen = copy_src.displayPrimaryGreen;
displayPrimaryBlue = copy_src.displayPrimaryBlue;
whitePoint = copy_src.whitePoint;
maxLuminance = copy_src.maxLuminance;
minLuminance = copy_src.minLuminance;
maxContentLightLevel = copy_src.maxContentLightLevel;
maxFrameAverageLightLevel = copy_src.maxFrameAverageLightLevel;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkHdrMetadataEXT::~safe_VkHdrMetadataEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkHdrMetadataEXT::initialize(const VkHdrMetadataEXT* in_struct)
{
sType = in_struct->sType;
displayPrimaryRed = in_struct->displayPrimaryRed;
displayPrimaryGreen = in_struct->displayPrimaryGreen;
displayPrimaryBlue = in_struct->displayPrimaryBlue;
whitePoint = in_struct->whitePoint;
maxLuminance = in_struct->maxLuminance;
minLuminance = in_struct->minLuminance;
maxContentLightLevel = in_struct->maxContentLightLevel;
maxFrameAverageLightLevel = in_struct->maxFrameAverageLightLevel;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkHdrMetadataEXT::initialize(const safe_VkHdrMetadataEXT* copy_src)
{
sType = copy_src->sType;
displayPrimaryRed = copy_src->displayPrimaryRed;
displayPrimaryGreen = copy_src->displayPrimaryGreen;
displayPrimaryBlue = copy_src->displayPrimaryBlue;
whitePoint = copy_src->whitePoint;
maxLuminance = copy_src->maxLuminance;
minLuminance = copy_src->minLuminance;
maxContentLightLevel = copy_src->maxContentLightLevel;
maxFrameAverageLightLevel = copy_src->maxFrameAverageLightLevel;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct) :
sType(in_struct->sType)
{
pNext = SafePnextCopy(in_struct->pNext);
pLabelName = SafeStringCopy(in_struct->pLabelName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = in_struct->color[i];
}
}
safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT),
pNext(nullptr),
pLabelName(nullptr)
{}
safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT(const safe_VkDebugUtilsLabelEXT& copy_src)
{
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
pLabelName = SafeStringCopy(copy_src.pLabelName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = copy_src.color[i];
}
}
safe_VkDebugUtilsLabelEXT& safe_VkDebugUtilsLabelEXT::operator=(const safe_VkDebugUtilsLabelEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pLabelName) delete [] pLabelName;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
pLabelName = SafeStringCopy(copy_src.pLabelName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = copy_src.color[i];
}
return *this;
}
safe_VkDebugUtilsLabelEXT::~safe_VkDebugUtilsLabelEXT()
{
if (pLabelName) delete [] pLabelName;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugUtilsLabelEXT::initialize(const VkDebugUtilsLabelEXT* in_struct)
{
sType = in_struct->sType;
pNext = SafePnextCopy(in_struct->pNext);
pLabelName = SafeStringCopy(in_struct->pLabelName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = in_struct->color[i];
}
}
void safe_VkDebugUtilsLabelEXT::initialize(const safe_VkDebugUtilsLabelEXT* copy_src)
{
sType = copy_src->sType;
pNext = SafePnextCopy(copy_src->pNext);
pLabelName = SafeStringCopy(copy_src->pLabelName);
for (uint32_t i = 0; i < 4; ++i) {
color[i] = copy_src->color[i];
}
}
safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct) :
sType(in_struct->sType),
objectType(in_struct->objectType),
objectHandle(in_struct->objectHandle)
{
pNext = SafePnextCopy(in_struct->pNext);
pObjectName = SafeStringCopy(in_struct->pObjectName);
}
safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT),
pNext(nullptr),
pObjectName(nullptr)
{}
safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src)
{
sType = copy_src.sType;
objectType = copy_src.objectType;
objectHandle = copy_src.objectHandle;
pNext = SafePnextCopy(copy_src.pNext);
pObjectName = SafeStringCopy(copy_src.pObjectName);
}
safe_VkDebugUtilsObjectNameInfoEXT& safe_VkDebugUtilsObjectNameInfoEXT::operator=(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pObjectName) delete [] pObjectName;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
objectType = copy_src.objectType;
objectHandle = copy_src.objectHandle;
pNext = SafePnextCopy(copy_src.pNext);
pObjectName = SafeStringCopy(copy_src.pObjectName);
return *this;
}
safe_VkDebugUtilsObjectNameInfoEXT::~safe_VkDebugUtilsObjectNameInfoEXT()
{
if (pObjectName) delete [] pObjectName;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugUtilsObjectNameInfoEXT::initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct)
{
sType = in_struct->sType;
objectType = in_struct->objectType;
objectHandle = in_struct->objectHandle;
pNext = SafePnextCopy(in_struct->pNext);
pObjectName = SafeStringCopy(in_struct->pObjectName);
}
void safe_VkDebugUtilsObjectNameInfoEXT::initialize(const safe_VkDebugUtilsObjectNameInfoEXT* copy_src)
{
sType = copy_src->sType;
objectType = copy_src->objectType;
objectHandle = copy_src->objectHandle;
pNext = SafePnextCopy(copy_src->pNext);
pObjectName = SafeStringCopy(copy_src->pObjectName);
}
safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
messageIdNumber(in_struct->messageIdNumber),
queueLabelCount(in_struct->queueLabelCount),
pQueueLabels(nullptr),
cmdBufLabelCount(in_struct->cmdBufLabelCount),
pCmdBufLabels(nullptr),
objectCount(in_struct->objectCount),
pObjects(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
pMessageIdName = SafeStringCopy(in_struct->pMessageIdName);
pMessage = SafeStringCopy(in_struct->pMessage);
if (queueLabelCount && in_struct->pQueueLabels) {
pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
for (uint32_t i = 0; i < queueLabelCount; ++i) {
pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]);
}
}
if (cmdBufLabelCount && in_struct->pCmdBufLabels) {
pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]);
}
}
if (objectCount && in_struct->pObjects) {
pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
for (uint32_t i = 0; i < objectCount; ++i) {
pObjects[i].initialize(&in_struct->pObjects[i]);
}
}
}
safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT),
pNext(nullptr),
pMessageIdName(nullptr),
pMessage(nullptr),
pQueueLabels(nullptr),
pCmdBufLabels(nullptr),
pObjects(nullptr)
{}
safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
messageIdNumber = copy_src.messageIdNumber;
queueLabelCount = copy_src.queueLabelCount;
pQueueLabels = nullptr;
cmdBufLabelCount = copy_src.cmdBufLabelCount;
pCmdBufLabels = nullptr;
objectCount = copy_src.objectCount;
pObjects = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
pMessageIdName = SafeStringCopy(copy_src.pMessageIdName);
pMessage = SafeStringCopy(copy_src.pMessage);
if (queueLabelCount && copy_src.pQueueLabels) {
pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
for (uint32_t i = 0; i < queueLabelCount; ++i) {
pQueueLabels[i].initialize(&copy_src.pQueueLabels[i]);
}
}
if (cmdBufLabelCount && copy_src.pCmdBufLabels) {
pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
pCmdBufLabels[i].initialize(&copy_src.pCmdBufLabels[i]);
}
}
if (objectCount && copy_src.pObjects) {
pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
for (uint32_t i = 0; i < objectCount; ++i) {
pObjects[i].initialize(&copy_src.pObjects[i]);
}
}
}
safe_VkDebugUtilsMessengerCallbackDataEXT& safe_VkDebugUtilsMessengerCallbackDataEXT::operator=(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pMessageIdName) delete [] pMessageIdName;
if (pMessage) delete [] pMessage;
if (pQueueLabels)
delete[] pQueueLabels;
if (pCmdBufLabels)
delete[] pCmdBufLabels;
if (pObjects)
delete[] pObjects;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
messageIdNumber = copy_src.messageIdNumber;
queueLabelCount = copy_src.queueLabelCount;
pQueueLabels = nullptr;
cmdBufLabelCount = copy_src.cmdBufLabelCount;
pCmdBufLabels = nullptr;
objectCount = copy_src.objectCount;
pObjects = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
pMessageIdName = SafeStringCopy(copy_src.pMessageIdName);
pMessage = SafeStringCopy(copy_src.pMessage);
if (queueLabelCount && copy_src.pQueueLabels) {
pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
for (uint32_t i = 0; i < queueLabelCount; ++i) {
pQueueLabels[i].initialize(&copy_src.pQueueLabels[i]);
}
}
if (cmdBufLabelCount && copy_src.pCmdBufLabels) {
pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
pCmdBufLabels[i].initialize(&copy_src.pCmdBufLabels[i]);
}
}
if (objectCount && copy_src.pObjects) {
pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
for (uint32_t i = 0; i < objectCount; ++i) {
pObjects[i].initialize(&copy_src.pObjects[i]);
}
}
return *this;
}
safe_VkDebugUtilsMessengerCallbackDataEXT::~safe_VkDebugUtilsMessengerCallbackDataEXT()
{
if (pMessageIdName) delete [] pMessageIdName;
if (pMessage) delete [] pMessage;
if (pQueueLabels)
delete[] pQueueLabels;
if (pCmdBufLabels)
delete[] pCmdBufLabels;
if (pObjects)
delete[] pObjects;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
messageIdNumber = in_struct->messageIdNumber;
queueLabelCount = in_struct->queueLabelCount;
pQueueLabels = nullptr;
cmdBufLabelCount = in_struct->cmdBufLabelCount;
pCmdBufLabels = nullptr;
objectCount = in_struct->objectCount;
pObjects = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
pMessageIdName = SafeStringCopy(in_struct->pMessageIdName);
pMessage = SafeStringCopy(in_struct->pMessage);
if (queueLabelCount && in_struct->pQueueLabels) {
pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
for (uint32_t i = 0; i < queueLabelCount; ++i) {
pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]);
}
}
if (cmdBufLabelCount && in_struct->pCmdBufLabels) {
pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]);
}
}
if (objectCount && in_struct->pObjects) {
pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
for (uint32_t i = 0; i < objectCount; ++i) {
pObjects[i].initialize(&in_struct->pObjects[i]);
}
}
}
void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const safe_VkDebugUtilsMessengerCallbackDataEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
messageIdNumber = copy_src->messageIdNumber;
queueLabelCount = copy_src->queueLabelCount;
pQueueLabels = nullptr;
cmdBufLabelCount = copy_src->cmdBufLabelCount;
pCmdBufLabels = nullptr;
objectCount = copy_src->objectCount;
pObjects = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
pMessageIdName = SafeStringCopy(copy_src->pMessageIdName);
pMessage = SafeStringCopy(copy_src->pMessage);
if (queueLabelCount && copy_src->pQueueLabels) {
pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
for (uint32_t i = 0; i < queueLabelCount; ++i) {
pQueueLabels[i].initialize(&copy_src->pQueueLabels[i]);
}
}
if (cmdBufLabelCount && copy_src->pCmdBufLabels) {
pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
pCmdBufLabels[i].initialize(&copy_src->pCmdBufLabels[i]);
}
}
if (objectCount && copy_src->pObjects) {
pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
for (uint32_t i = 0; i < objectCount; ++i) {
pObjects[i].initialize(&copy_src->pObjects[i]);
}
}
}
safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
messageSeverity(in_struct->messageSeverity),
messageType(in_struct->messageType),
pfnUserCallback(in_struct->pfnUserCallback),
pUserData(in_struct->pUserData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT),
pNext(nullptr),
pUserData(nullptr)
{}
safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT(const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
messageSeverity = copy_src.messageSeverity;
messageType = copy_src.messageType;
pfnUserCallback = copy_src.pfnUserCallback;
pUserData = copy_src.pUserData;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDebugUtilsMessengerCreateInfoEXT& safe_VkDebugUtilsMessengerCreateInfoEXT::operator=(const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
messageSeverity = copy_src.messageSeverity;
messageType = copy_src.messageType;
pfnUserCallback = copy_src.pfnUserCallback;
pUserData = copy_src.pUserData;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDebugUtilsMessengerCreateInfoEXT::~safe_VkDebugUtilsMessengerCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugUtilsMessengerCreateInfoEXT::initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
messageSeverity = in_struct->messageSeverity;
messageType = in_struct->messageType;
pfnUserCallback = in_struct->pfnUserCallback;
pUserData = in_struct->pUserData;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDebugUtilsMessengerCreateInfoEXT::initialize(const safe_VkDebugUtilsMessengerCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
messageSeverity = copy_src->messageSeverity;
messageType = copy_src->messageType;
pfnUserCallback = copy_src->pfnUserCallback;
pUserData = copy_src->pUserData;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct) :
sType(in_struct->sType),
objectType(in_struct->objectType),
objectHandle(in_struct->objectHandle),
tagName(in_struct->tagName),
tagSize(in_struct->tagSize),
pTag(in_struct->pTag)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT),
pNext(nullptr),
pTag(nullptr)
{}
safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src)
{
sType = copy_src.sType;
objectType = copy_src.objectType;
objectHandle = copy_src.objectHandle;
tagName = copy_src.tagName;
tagSize = copy_src.tagSize;
pTag = copy_src.pTag;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDebugUtilsObjectTagInfoEXT& safe_VkDebugUtilsObjectTagInfoEXT::operator=(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
objectType = copy_src.objectType;
objectHandle = copy_src.objectHandle;
tagName = copy_src.tagName;
tagSize = copy_src.tagSize;
pTag = copy_src.pTag;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDebugUtilsObjectTagInfoEXT::~safe_VkDebugUtilsObjectTagInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDebugUtilsObjectTagInfoEXT::initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct)
{
sType = in_struct->sType;
objectType = in_struct->objectType;
objectHandle = in_struct->objectHandle;
tagName = in_struct->tagName;
tagSize = in_struct->tagSize;
pTag = in_struct->pTag;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDebugUtilsObjectTagInfoEXT::initialize(const safe_VkDebugUtilsObjectTagInfoEXT* copy_src)
{
sType = copy_src->sType;
objectType = copy_src->objectType;
objectHandle = copy_src->objectHandle;
tagName = copy_src->tagName;
tagSize = copy_src->tagSize;
pTag = copy_src->pTag;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_ANDROID_KHR
safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID* in_struct) :
sType(in_struct->sType),
androidHardwareBufferUsage(in_struct->androidHardwareBufferUsage)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID() :
sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID),
pNext(nullptr)
{}
safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID(const safe_VkAndroidHardwareBufferUsageANDROID& copy_src)
{
sType = copy_src.sType;
androidHardwareBufferUsage = copy_src.androidHardwareBufferUsage;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAndroidHardwareBufferUsageANDROID& safe_VkAndroidHardwareBufferUsageANDROID::operator=(const safe_VkAndroidHardwareBufferUsageANDROID& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
androidHardwareBufferUsage = copy_src.androidHardwareBufferUsage;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAndroidHardwareBufferUsageANDROID::~safe_VkAndroidHardwareBufferUsageANDROID()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct)
{
sType = in_struct->sType;
androidHardwareBufferUsage = in_struct->androidHardwareBufferUsage;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const safe_VkAndroidHardwareBufferUsageANDROID* copy_src)
{
sType = copy_src->sType;
androidHardwareBufferUsage = copy_src->androidHardwareBufferUsage;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_ANDROID_KHR
safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID* in_struct) :
sType(in_struct->sType),
allocationSize(in_struct->allocationSize),
memoryTypeBits(in_struct->memoryTypeBits)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID() :
sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID),
pNext(nullptr)
{}
safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID(const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src)
{
sType = copy_src.sType;
allocationSize = copy_src.allocationSize;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAndroidHardwareBufferPropertiesANDROID& safe_VkAndroidHardwareBufferPropertiesANDROID::operator=(const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
allocationSize = copy_src.allocationSize;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAndroidHardwareBufferPropertiesANDROID::~safe_VkAndroidHardwareBufferPropertiesANDROID()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct)
{
sType = in_struct->sType;
allocationSize = in_struct->allocationSize;
memoryTypeBits = in_struct->memoryTypeBits;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const safe_VkAndroidHardwareBufferPropertiesANDROID* copy_src)
{
sType = copy_src->sType;
allocationSize = copy_src->allocationSize;
memoryTypeBits = copy_src->memoryTypeBits;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_ANDROID_KHR
safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct) :
sType(in_struct->sType),
format(in_struct->format),
externalFormat(in_struct->externalFormat),
formatFeatures(in_struct->formatFeatures),
samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents),
suggestedYcbcrModel(in_struct->suggestedYcbcrModel),
suggestedYcbcrRange(in_struct->suggestedYcbcrRange),
suggestedXChromaOffset(in_struct->suggestedXChromaOffset),
suggestedYChromaOffset(in_struct->suggestedYChromaOffset)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID() :
sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID),
pNext(nullptr)
{}
safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src)
{
sType = copy_src.sType;
format = copy_src.format;
externalFormat = copy_src.externalFormat;
formatFeatures = copy_src.formatFeatures;
samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAndroidHardwareBufferFormatPropertiesANDROID& safe_VkAndroidHardwareBufferFormatPropertiesANDROID::operator=(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
format = copy_src.format;
externalFormat = copy_src.externalFormat;
formatFeatures = copy_src.formatFeatures;
samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAndroidHardwareBufferFormatPropertiesANDROID::~safe_VkAndroidHardwareBufferFormatPropertiesANDROID()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct)
{
sType = in_struct->sType;
format = in_struct->format;
externalFormat = in_struct->externalFormat;
formatFeatures = in_struct->formatFeatures;
samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents;
suggestedYcbcrModel = in_struct->suggestedYcbcrModel;
suggestedYcbcrRange = in_struct->suggestedYcbcrRange;
suggestedXChromaOffset = in_struct->suggestedXChromaOffset;
suggestedYChromaOffset = in_struct->suggestedYChromaOffset;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID* copy_src)
{
sType = copy_src->sType;
format = copy_src->format;
externalFormat = copy_src->externalFormat;
formatFeatures = copy_src->formatFeatures;
samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents;
suggestedYcbcrModel = copy_src->suggestedYcbcrModel;
suggestedYcbcrRange = copy_src->suggestedYcbcrRange;
suggestedXChromaOffset = copy_src->suggestedXChromaOffset;
suggestedYChromaOffset = copy_src->suggestedYChromaOffset;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_ANDROID_KHR
safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID* in_struct) :
sType(in_struct->sType),
buffer(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
buffer = in_struct->buffer;
}
safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID() :
sType(VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID),
pNext(nullptr),
buffer(nullptr)
{}
safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID(const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src)
{
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
buffer = copy_src.buffer;
}
safe_VkImportAndroidHardwareBufferInfoANDROID& safe_VkImportAndroidHardwareBufferInfoANDROID::operator=(const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
buffer = copy_src.buffer;
return *this;
}
safe_VkImportAndroidHardwareBufferInfoANDROID::~safe_VkImportAndroidHardwareBufferInfoANDROID()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct)
{
sType = in_struct->sType;
pNext = SafePnextCopy(in_struct->pNext);
buffer = in_struct->buffer;
}
void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const safe_VkImportAndroidHardwareBufferInfoANDROID* copy_src)
{
sType = copy_src->sType;
pNext = SafePnextCopy(copy_src->pNext);
buffer = copy_src->buffer;
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_ANDROID_KHR
safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct) :
sType(in_struct->sType),
memory(in_struct->memory)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID() :
sType(VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID),
pNext(nullptr)
{}
safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src)
{
sType = copy_src.sType;
memory = copy_src.memory;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::operator=(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memory = copy_src.memory;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::~safe_VkMemoryGetAndroidHardwareBufferInfoANDROID()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct)
{
sType = in_struct->sType;
memory = in_struct->memory;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID* copy_src)
{
sType = copy_src->sType;
memory = copy_src->memory;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_ANDROID_KHR
safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID(const VkExternalFormatANDROID* in_struct) :
sType(in_struct->sType),
externalFormat(in_struct->externalFormat)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID() :
sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID),
pNext(nullptr)
{}
safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID(const safe_VkExternalFormatANDROID& copy_src)
{
sType = copy_src.sType;
externalFormat = copy_src.externalFormat;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalFormatANDROID& safe_VkExternalFormatANDROID::operator=(const safe_VkExternalFormatANDROID& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
externalFormat = copy_src.externalFormat;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalFormatANDROID::~safe_VkExternalFormatANDROID()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkExternalFormatANDROID::initialize(const VkExternalFormatANDROID* in_struct)
{
sType = in_struct->sType;
externalFormat = in_struct->externalFormat;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkExternalFormatANDROID::initialize(const safe_VkExternalFormatANDROID* copy_src)
{
sType = copy_src->sType;
externalFormat = copy_src->externalFormat;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* in_struct) :
sType(in_struct->sType),
inlineUniformBlock(in_struct->inlineUniformBlock),
descriptorBindingInlineUniformBlockUpdateAfterBind(in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& copy_src)
{
sType = copy_src.sType;
inlineUniformBlock = copy_src.inlineUniformBlock;
descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::operator=(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
inlineUniformBlock = copy_src.inlineUniformBlock;
descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::~safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::initialize(const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* in_struct)
{
sType = in_struct->sType;
inlineUniformBlock = in_struct->inlineUniformBlock;
descriptorBindingInlineUniformBlockUpdateAfterBind = in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::initialize(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT* copy_src)
{
sType = copy_src->sType;
inlineUniformBlock = copy_src->inlineUniformBlock;
descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src->descriptorBindingInlineUniformBlockUpdateAfterBind;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* in_struct) :
sType(in_struct->sType),
maxInlineUniformBlockSize(in_struct->maxInlineUniformBlockSize),
maxPerStageDescriptorInlineUniformBlocks(in_struct->maxPerStageDescriptorInlineUniformBlocks),
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks),
maxDescriptorSetInlineUniformBlocks(in_struct->maxDescriptorSetInlineUniformBlocks),
maxDescriptorSetUpdateAfterBindInlineUniformBlocks(in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& copy_src)
{
sType = copy_src.sType;
maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize;
maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks;
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks;
maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::operator=(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize;
maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks;
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks;
maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::~safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::initialize(const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* in_struct)
{
sType = in_struct->sType;
maxInlineUniformBlockSize = in_struct->maxInlineUniformBlockSize;
maxPerStageDescriptorInlineUniformBlocks = in_struct->maxPerStageDescriptorInlineUniformBlocks;
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
maxDescriptorSetInlineUniformBlocks = in_struct->maxDescriptorSetInlineUniformBlocks;
maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::initialize(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT* copy_src)
{
sType = copy_src->sType;
maxInlineUniformBlockSize = copy_src->maxInlineUniformBlockSize;
maxPerStageDescriptorInlineUniformBlocks = copy_src->maxPerStageDescriptorInlineUniformBlocks;
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
maxDescriptorSetInlineUniformBlocks = copy_src->maxDescriptorSetInlineUniformBlocks;
maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkWriteDescriptorSetInlineUniformBlockEXT::safe_VkWriteDescriptorSetInlineUniformBlockEXT(const VkWriteDescriptorSetInlineUniformBlockEXT* in_struct) :
sType(in_struct->sType),
dataSize(in_struct->dataSize),
pData(in_struct->pData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkWriteDescriptorSetInlineUniformBlockEXT::safe_VkWriteDescriptorSetInlineUniformBlockEXT() :
sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT),
pNext(nullptr),
pData(nullptr)
{}
safe_VkWriteDescriptorSetInlineUniformBlockEXT::safe_VkWriteDescriptorSetInlineUniformBlockEXT(const safe_VkWriteDescriptorSetInlineUniformBlockEXT& copy_src)
{
sType = copy_src.sType;
dataSize = copy_src.dataSize;
pData = copy_src.pData;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkWriteDescriptorSetInlineUniformBlockEXT& safe_VkWriteDescriptorSetInlineUniformBlockEXT::operator=(const safe_VkWriteDescriptorSetInlineUniformBlockEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
dataSize = copy_src.dataSize;
pData = copy_src.pData;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkWriteDescriptorSetInlineUniformBlockEXT::~safe_VkWriteDescriptorSetInlineUniformBlockEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkWriteDescriptorSetInlineUniformBlockEXT::initialize(const VkWriteDescriptorSetInlineUniformBlockEXT* in_struct)
{
sType = in_struct->sType;
dataSize = in_struct->dataSize;
pData = in_struct->pData;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkWriteDescriptorSetInlineUniformBlockEXT::initialize(const safe_VkWriteDescriptorSetInlineUniformBlockEXT* copy_src)
{
sType = copy_src->sType;
dataSize = copy_src->dataSize;
pData = copy_src->pData;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* in_struct) :
sType(in_struct->sType),
maxInlineUniformBlockBindings(in_struct->maxInlineUniformBlockBindings)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
maxInlineUniformBlockBindings = copy_src.maxInlineUniformBlockBindings;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::operator=(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxInlineUniformBlockBindings = copy_src.maxInlineUniformBlockBindings;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::~safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::initialize(const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
maxInlineUniformBlockBindings = in_struct->maxInlineUniformBlockBindings;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::initialize(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
maxInlineUniformBlockBindings = copy_src->maxInlineUniformBlockBindings;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct) :
sType(in_struct->sType),
sampleLocationsPerPixel(in_struct->sampleLocationsPerPixel),
sampleLocationGridSize(in_struct->sampleLocationGridSize),
sampleLocationsCount(in_struct->sampleLocationsCount),
pSampleLocations(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSampleLocations) {
pSampleLocations = new VkSampleLocationEXT[in_struct->sampleLocationsCount];
memcpy ((void *)pSampleLocations, (void *)in_struct->pSampleLocations, sizeof(VkSampleLocationEXT)*in_struct->sampleLocationsCount);
}
}
safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT() :
sType(VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT),
pNext(nullptr),
pSampleLocations(nullptr)
{}
safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const safe_VkSampleLocationsInfoEXT& copy_src)
{
sType = copy_src.sType;
sampleLocationsPerPixel = copy_src.sampleLocationsPerPixel;
sampleLocationGridSize = copy_src.sampleLocationGridSize;
sampleLocationsCount = copy_src.sampleLocationsCount;
pSampleLocations = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSampleLocations) {
pSampleLocations = new VkSampleLocationEXT[copy_src.sampleLocationsCount];
memcpy ((void *)pSampleLocations, (void *)copy_src.pSampleLocations, sizeof(VkSampleLocationEXT)*copy_src.sampleLocationsCount);
}
}
safe_VkSampleLocationsInfoEXT& safe_VkSampleLocationsInfoEXT::operator=(const safe_VkSampleLocationsInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pSampleLocations)
delete[] pSampleLocations;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
sampleLocationsPerPixel = copy_src.sampleLocationsPerPixel;
sampleLocationGridSize = copy_src.sampleLocationGridSize;
sampleLocationsCount = copy_src.sampleLocationsCount;
pSampleLocations = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSampleLocations) {
pSampleLocations = new VkSampleLocationEXT[copy_src.sampleLocationsCount];
memcpy ((void *)pSampleLocations, (void *)copy_src.pSampleLocations, sizeof(VkSampleLocationEXT)*copy_src.sampleLocationsCount);
}
return *this;
}
safe_VkSampleLocationsInfoEXT::~safe_VkSampleLocationsInfoEXT()
{
if (pSampleLocations)
delete[] pSampleLocations;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSampleLocationsInfoEXT::initialize(const VkSampleLocationsInfoEXT* in_struct)
{
sType = in_struct->sType;
sampleLocationsPerPixel = in_struct->sampleLocationsPerPixel;
sampleLocationGridSize = in_struct->sampleLocationGridSize;
sampleLocationsCount = in_struct->sampleLocationsCount;
pSampleLocations = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSampleLocations) {
pSampleLocations = new VkSampleLocationEXT[in_struct->sampleLocationsCount];
memcpy ((void *)pSampleLocations, (void *)in_struct->pSampleLocations, sizeof(VkSampleLocationEXT)*in_struct->sampleLocationsCount);
}
}
void safe_VkSampleLocationsInfoEXT::initialize(const safe_VkSampleLocationsInfoEXT* copy_src)
{
sType = copy_src->sType;
sampleLocationsPerPixel = copy_src->sampleLocationsPerPixel;
sampleLocationGridSize = copy_src->sampleLocationGridSize;
sampleLocationsCount = copy_src->sampleLocationsCount;
pSampleLocations = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pSampleLocations) {
pSampleLocations = new VkSampleLocationEXT[copy_src->sampleLocationsCount];
memcpy ((void *)pSampleLocations, (void *)copy_src->pSampleLocations, sizeof(VkSampleLocationEXT)*copy_src->sampleLocationsCount);
}
}
safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct) :
sType(in_struct->sType),
attachmentInitialSampleLocationsCount(in_struct->attachmentInitialSampleLocationsCount),
pAttachmentInitialSampleLocations(nullptr),
postSubpassSampleLocationsCount(in_struct->postSubpassSampleLocationsCount),
pPostSubpassSampleLocations(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttachmentInitialSampleLocations) {
pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount];
memcpy ((void *)pAttachmentInitialSampleLocations, (void *)in_struct->pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*in_struct->attachmentInitialSampleLocationsCount);
}
if (in_struct->pPostSubpassSampleLocations) {
pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[in_struct->postSubpassSampleLocationsCount];
memcpy ((void *)pPostSubpassSampleLocations, (void *)in_struct->pPostSubpassSampleLocations, sizeof(VkSubpassSampleLocationsEXT)*in_struct->postSubpassSampleLocationsCount);
}
}
safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT),
pNext(nullptr),
pAttachmentInitialSampleLocations(nullptr),
pPostSubpassSampleLocations(nullptr)
{}
safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT(const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src)
{
sType = copy_src.sType;
attachmentInitialSampleLocationsCount = copy_src.attachmentInitialSampleLocationsCount;
pAttachmentInitialSampleLocations = nullptr;
postSubpassSampleLocationsCount = copy_src.postSubpassSampleLocationsCount;
pPostSubpassSampleLocations = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttachmentInitialSampleLocations) {
pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src.attachmentInitialSampleLocationsCount];
memcpy ((void *)pAttachmentInitialSampleLocations, (void *)copy_src.pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*copy_src.attachmentInitialSampleLocationsCount);
}
if (copy_src.pPostSubpassSampleLocations) {
pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src.postSubpassSampleLocationsCount];
memcpy ((void *)pPostSubpassSampleLocations, (void *)copy_src.pPostSubpassSampleLocations, sizeof(VkSubpassSampleLocationsEXT)*copy_src.postSubpassSampleLocationsCount);
}
}
safe_VkRenderPassSampleLocationsBeginInfoEXT& safe_VkRenderPassSampleLocationsBeginInfoEXT::operator=(const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pAttachmentInitialSampleLocations)
delete[] pAttachmentInitialSampleLocations;
if (pPostSubpassSampleLocations)
delete[] pPostSubpassSampleLocations;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
attachmentInitialSampleLocationsCount = copy_src.attachmentInitialSampleLocationsCount;
pAttachmentInitialSampleLocations = nullptr;
postSubpassSampleLocationsCount = copy_src.postSubpassSampleLocationsCount;
pPostSubpassSampleLocations = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pAttachmentInitialSampleLocations) {
pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src.attachmentInitialSampleLocationsCount];
memcpy ((void *)pAttachmentInitialSampleLocations, (void *)copy_src.pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*copy_src.attachmentInitialSampleLocationsCount);
}
if (copy_src.pPostSubpassSampleLocations) {
pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src.postSubpassSampleLocationsCount];
memcpy ((void *)pPostSubpassSampleLocations, (void *)copy_src.pPostSubpassSampleLocations, sizeof(VkSubpassSampleLocationsEXT)*copy_src.postSubpassSampleLocationsCount);
}
return *this;
}
safe_VkRenderPassSampleLocationsBeginInfoEXT::~safe_VkRenderPassSampleLocationsBeginInfoEXT()
{
if (pAttachmentInitialSampleLocations)
delete[] pAttachmentInitialSampleLocations;
if (pPostSubpassSampleLocations)
delete[] pPostSubpassSampleLocations;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct)
{
sType = in_struct->sType;
attachmentInitialSampleLocationsCount = in_struct->attachmentInitialSampleLocationsCount;
pAttachmentInitialSampleLocations = nullptr;
postSubpassSampleLocationsCount = in_struct->postSubpassSampleLocationsCount;
pPostSubpassSampleLocations = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pAttachmentInitialSampleLocations) {
pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount];
memcpy ((void *)pAttachmentInitialSampleLocations, (void *)in_struct->pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*in_struct->attachmentInitialSampleLocationsCount);
}
if (in_struct->pPostSubpassSampleLocations) {
pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[in_struct->postSubpassSampleLocationsCount];
memcpy ((void *)pPostSubpassSampleLocations, (void *)in_struct->pPostSubpassSampleLocations, sizeof(VkSubpassSampleLocationsEXT)*in_struct->postSubpassSampleLocationsCount);
}
}
void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const safe_VkRenderPassSampleLocationsBeginInfoEXT* copy_src)
{
sType = copy_src->sType;
attachmentInitialSampleLocationsCount = copy_src->attachmentInitialSampleLocationsCount;
pAttachmentInitialSampleLocations = nullptr;
postSubpassSampleLocationsCount = copy_src->postSubpassSampleLocationsCount;
pPostSubpassSampleLocations = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pAttachmentInitialSampleLocations) {
pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src->attachmentInitialSampleLocationsCount];
memcpy ((void *)pAttachmentInitialSampleLocations, (void *)copy_src->pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*copy_src->attachmentInitialSampleLocationsCount);
}
if (copy_src->pPostSubpassSampleLocations) {
pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src->postSubpassSampleLocationsCount];
memcpy ((void *)pPostSubpassSampleLocations, (void *)copy_src->pPostSubpassSampleLocations, sizeof(VkSubpassSampleLocationsEXT)*copy_src->postSubpassSampleLocationsCount);
}
}
safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct) :
sType(in_struct->sType),
sampleLocationsEnable(in_struct->sampleLocationsEnable),
sampleLocationsInfo(&in_struct->sampleLocationsInfo)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
sampleLocationsEnable = copy_src.sampleLocationsEnable;
sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineSampleLocationsStateCreateInfoEXT& safe_VkPipelineSampleLocationsStateCreateInfoEXT::operator=(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
sampleLocationsEnable = copy_src.sampleLocationsEnable;
sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineSampleLocationsStateCreateInfoEXT::~safe_VkPipelineSampleLocationsStateCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineSampleLocationsStateCreateInfoEXT::initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
sampleLocationsEnable = in_struct->sampleLocationsEnable;
sampleLocationsInfo.initialize(&in_struct->sampleLocationsInfo);
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineSampleLocationsStateCreateInfoEXT::initialize(const safe_VkPipelineSampleLocationsStateCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
sampleLocationsEnable = copy_src->sampleLocationsEnable;
sampleLocationsInfo.initialize(&copy_src->sampleLocationsInfo);
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct) :
sType(in_struct->sType),
sampleLocationSampleCounts(in_struct->sampleLocationSampleCounts),
maxSampleLocationGridSize(in_struct->maxSampleLocationGridSize),
sampleLocationSubPixelBits(in_struct->sampleLocationSubPixelBits),
variableSampleLocations(in_struct->variableSampleLocations)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 2; ++i) {
sampleLocationCoordinateRange[i] = in_struct->sampleLocationCoordinateRange[i];
}
}
safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src)
{
sType = copy_src.sType;
sampleLocationSampleCounts = copy_src.sampleLocationSampleCounts;
maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
sampleLocationSubPixelBits = copy_src.sampleLocationSubPixelBits;
variableSampleLocations = copy_src.variableSampleLocations;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 2; ++i) {
sampleLocationCoordinateRange[i] = copy_src.sampleLocationCoordinateRange[i];
}
}
safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::operator=(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
sampleLocationSampleCounts = copy_src.sampleLocationSampleCounts;
maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
sampleLocationSubPixelBits = copy_src.sampleLocationSubPixelBits;
variableSampleLocations = copy_src.variableSampleLocations;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 2; ++i) {
sampleLocationCoordinateRange[i] = copy_src.sampleLocationCoordinateRange[i];
}
return *this;
}
safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::~safe_VkPhysicalDeviceSampleLocationsPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct)
{
sType = in_struct->sType;
sampleLocationSampleCounts = in_struct->sampleLocationSampleCounts;
maxSampleLocationGridSize = in_struct->maxSampleLocationGridSize;
sampleLocationSubPixelBits = in_struct->sampleLocationSubPixelBits;
variableSampleLocations = in_struct->variableSampleLocations;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 2; ++i) {
sampleLocationCoordinateRange[i] = in_struct->sampleLocationCoordinateRange[i];
}
}
void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT* copy_src)
{
sType = copy_src->sType;
sampleLocationSampleCounts = copy_src->sampleLocationSampleCounts;
maxSampleLocationGridSize = copy_src->maxSampleLocationGridSize;
sampleLocationSubPixelBits = copy_src->sampleLocationSubPixelBits;
variableSampleLocations = copy_src->variableSampleLocations;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < 2; ++i) {
sampleLocationCoordinateRange[i] = copy_src->sampleLocationCoordinateRange[i];
}
}
safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct) :
sType(in_struct->sType),
maxSampleLocationGridSize(in_struct->maxSampleLocationGridSize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT() :
sType(VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT(const safe_VkMultisamplePropertiesEXT& copy_src)
{
sType = copy_src.sType;
maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMultisamplePropertiesEXT& safe_VkMultisamplePropertiesEXT::operator=(const safe_VkMultisamplePropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMultisamplePropertiesEXT::~safe_VkMultisamplePropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMultisamplePropertiesEXT::initialize(const VkMultisamplePropertiesEXT* in_struct)
{
sType = in_struct->sType;
maxSampleLocationGridSize = in_struct->maxSampleLocationGridSize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMultisamplePropertiesEXT::initialize(const safe_VkMultisamplePropertiesEXT* copy_src)
{
sType = copy_src->sType;
maxSampleLocationGridSize = copy_src->maxSampleLocationGridSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct) :
sType(in_struct->sType),
advancedBlendCoherentOperations(in_struct->advancedBlendCoherentOperations)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src)
{
sType = copy_src.sType;
advancedBlendCoherentOperations = copy_src.advancedBlendCoherentOperations;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
advancedBlendCoherentOperations = copy_src.advancedBlendCoherentOperations;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct)
{
sType = in_struct->sType;
advancedBlendCoherentOperations = in_struct->advancedBlendCoherentOperations;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* copy_src)
{
sType = copy_src->sType;
advancedBlendCoherentOperations = copy_src->advancedBlendCoherentOperations;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct) :
sType(in_struct->sType),
advancedBlendMaxColorAttachments(in_struct->advancedBlendMaxColorAttachments),
advancedBlendIndependentBlend(in_struct->advancedBlendIndependentBlend),
advancedBlendNonPremultipliedSrcColor(in_struct->advancedBlendNonPremultipliedSrcColor),
advancedBlendNonPremultipliedDstColor(in_struct->advancedBlendNonPremultipliedDstColor),
advancedBlendCorrelatedOverlap(in_struct->advancedBlendCorrelatedOverlap),
advancedBlendAllOperations(in_struct->advancedBlendAllOperations)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src)
{
sType = copy_src.sType;
advancedBlendMaxColorAttachments = copy_src.advancedBlendMaxColorAttachments;
advancedBlendIndependentBlend = copy_src.advancedBlendIndependentBlend;
advancedBlendNonPremultipliedSrcColor = copy_src.advancedBlendNonPremultipliedSrcColor;
advancedBlendNonPremultipliedDstColor = copy_src.advancedBlendNonPremultipliedDstColor;
advancedBlendCorrelatedOverlap = copy_src.advancedBlendCorrelatedOverlap;
advancedBlendAllOperations = copy_src.advancedBlendAllOperations;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
advancedBlendMaxColorAttachments = copy_src.advancedBlendMaxColorAttachments;
advancedBlendIndependentBlend = copy_src.advancedBlendIndependentBlend;
advancedBlendNonPremultipliedSrcColor = copy_src.advancedBlendNonPremultipliedSrcColor;
advancedBlendNonPremultipliedDstColor = copy_src.advancedBlendNonPremultipliedDstColor;
advancedBlendCorrelatedOverlap = copy_src.advancedBlendCorrelatedOverlap;
advancedBlendAllOperations = copy_src.advancedBlendAllOperations;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct)
{
sType = in_struct->sType;
advancedBlendMaxColorAttachments = in_struct->advancedBlendMaxColorAttachments;
advancedBlendIndependentBlend = in_struct->advancedBlendIndependentBlend;
advancedBlendNonPremultipliedSrcColor = in_struct->advancedBlendNonPremultipliedSrcColor;
advancedBlendNonPremultipliedDstColor = in_struct->advancedBlendNonPremultipliedDstColor;
advancedBlendCorrelatedOverlap = in_struct->advancedBlendCorrelatedOverlap;
advancedBlendAllOperations = in_struct->advancedBlendAllOperations;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* copy_src)
{
sType = copy_src->sType;
advancedBlendMaxColorAttachments = copy_src->advancedBlendMaxColorAttachments;
advancedBlendIndependentBlend = copy_src->advancedBlendIndependentBlend;
advancedBlendNonPremultipliedSrcColor = copy_src->advancedBlendNonPremultipliedSrcColor;
advancedBlendNonPremultipliedDstColor = copy_src->advancedBlendNonPremultipliedDstColor;
advancedBlendCorrelatedOverlap = copy_src->advancedBlendCorrelatedOverlap;
advancedBlendAllOperations = copy_src->advancedBlendAllOperations;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct) :
sType(in_struct->sType),
srcPremultiplied(in_struct->srcPremultiplied),
dstPremultiplied(in_struct->dstPremultiplied),
blendOverlap(in_struct->blendOverlap)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
srcPremultiplied = copy_src.srcPremultiplied;
dstPremultiplied = copy_src.dstPremultiplied;
blendOverlap = copy_src.blendOverlap;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::operator=(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
srcPremultiplied = copy_src.srcPremultiplied;
dstPremultiplied = copy_src.dstPremultiplied;
blendOverlap = copy_src.blendOverlap;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
srcPremultiplied = in_struct->srcPremultiplied;
dstPremultiplied = in_struct->dstPremultiplied;
blendOverlap = in_struct->blendOverlap;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
srcPremultiplied = copy_src->srcPremultiplied;
dstPremultiplied = copy_src->dstPremultiplied;
blendOverlap = copy_src->blendOverlap;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
coverageToColorEnable(in_struct->coverageToColorEnable),
coverageToColorLocation(in_struct->coverageToColorLocation)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
coverageToColorEnable = copy_src.coverageToColorEnable;
coverageToColorLocation = copy_src.coverageToColorLocation;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineCoverageToColorStateCreateInfoNV& safe_VkPipelineCoverageToColorStateCreateInfoNV::operator=(const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
coverageToColorEnable = copy_src.coverageToColorEnable;
coverageToColorLocation = copy_src.coverageToColorLocation;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineCoverageToColorStateCreateInfoNV::~safe_VkPipelineCoverageToColorStateCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
coverageToColorEnable = in_struct->coverageToColorEnable;
coverageToColorLocation = in_struct->coverageToColorLocation;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
coverageToColorEnable = copy_src->coverageToColorEnable;
coverageToColorLocation = copy_src->coverageToColorLocation;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
coverageModulationMode(in_struct->coverageModulationMode),
coverageModulationTableEnable(in_struct->coverageModulationTableEnable),
coverageModulationTableCount(in_struct->coverageModulationTableCount),
pCoverageModulationTable(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pCoverageModulationTable) {
pCoverageModulationTable = new float[in_struct->coverageModulationTableCount];
memcpy ((void *)pCoverageModulationTable, (void *)in_struct->pCoverageModulationTable, sizeof(float)*in_struct->coverageModulationTableCount);
}
}
safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV),
pNext(nullptr),
pCoverageModulationTable(nullptr)
{}
safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV(const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
coverageModulationMode = copy_src.coverageModulationMode;
coverageModulationTableEnable = copy_src.coverageModulationTableEnable;
coverageModulationTableCount = copy_src.coverageModulationTableCount;
pCoverageModulationTable = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pCoverageModulationTable) {
pCoverageModulationTable = new float[copy_src.coverageModulationTableCount];
memcpy ((void *)pCoverageModulationTable, (void *)copy_src.pCoverageModulationTable, sizeof(float)*copy_src.coverageModulationTableCount);
}
}
safe_VkPipelineCoverageModulationStateCreateInfoNV& safe_VkPipelineCoverageModulationStateCreateInfoNV::operator=(const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pCoverageModulationTable)
delete[] pCoverageModulationTable;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
coverageModulationMode = copy_src.coverageModulationMode;
coverageModulationTableEnable = copy_src.coverageModulationTableEnable;
coverageModulationTableCount = copy_src.coverageModulationTableCount;
pCoverageModulationTable = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pCoverageModulationTable) {
pCoverageModulationTable = new float[copy_src.coverageModulationTableCount];
memcpy ((void *)pCoverageModulationTable, (void *)copy_src.pCoverageModulationTable, sizeof(float)*copy_src.coverageModulationTableCount);
}
return *this;
}
safe_VkPipelineCoverageModulationStateCreateInfoNV::~safe_VkPipelineCoverageModulationStateCreateInfoNV()
{
if (pCoverageModulationTable)
delete[] pCoverageModulationTable;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
coverageModulationMode = in_struct->coverageModulationMode;
coverageModulationTableEnable = in_struct->coverageModulationTableEnable;
coverageModulationTableCount = in_struct->coverageModulationTableCount;
pCoverageModulationTable = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pCoverageModulationTable) {
pCoverageModulationTable = new float[in_struct->coverageModulationTableCount];
memcpy ((void *)pCoverageModulationTable, (void *)in_struct->pCoverageModulationTable, sizeof(float)*in_struct->coverageModulationTableCount);
}
}
void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const safe_VkPipelineCoverageModulationStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
coverageModulationMode = copy_src->coverageModulationMode;
coverageModulationTableEnable = copy_src->coverageModulationTableEnable;
coverageModulationTableCount = copy_src->coverageModulationTableCount;
pCoverageModulationTable = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pCoverageModulationTable) {
pCoverageModulationTable = new float[copy_src->coverageModulationTableCount];
memcpy ((void *)pCoverageModulationTable, (void *)copy_src->pCoverageModulationTable, sizeof(float)*copy_src->coverageModulationTableCount);
}
}
safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct) :
sType(in_struct->sType),
shaderSMCount(in_struct->shaderSMCount),
shaderWarpsPerSM(in_struct->shaderWarpsPerSM)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src)
{
sType = copy_src.sType;
shaderSMCount = copy_src.shaderSMCount;
shaderWarpsPerSM = copy_src.shaderWarpsPerSM;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderSMCount = copy_src.shaderSMCount;
shaderWarpsPerSM = copy_src.shaderWarpsPerSM;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::~safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct)
{
sType = in_struct->sType;
shaderSMCount = in_struct->shaderSMCount;
shaderWarpsPerSM = in_struct->shaderWarpsPerSM;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* copy_src)
{
sType = copy_src->sType;
shaderSMCount = copy_src->shaderSMCount;
shaderWarpsPerSM = copy_src->shaderWarpsPerSM;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct) :
sType(in_struct->sType),
shaderSMBuiltins(in_struct->shaderSMBuiltins)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src)
{
sType = copy_src.sType;
shaderSMBuiltins = copy_src.shaderSMBuiltins;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderSMBuiltins = copy_src.shaderSMBuiltins;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::~safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct)
{
sType = in_struct->sType;
shaderSMBuiltins = in_struct->shaderSMBuiltins;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* copy_src)
{
sType = copy_src->sType;
shaderSMBuiltins = copy_src->shaderSMBuiltins;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* in_struct) :
sType(in_struct->sType),
drmFormatModifierCount(in_struct->drmFormatModifierCount),
pDrmFormatModifierProperties(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDrmFormatModifierProperties) {
pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[in_struct->drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifierProperties, (void *)in_struct->pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*in_struct->drmFormatModifierCount);
}
}
safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT() :
sType(VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT),
pNext(nullptr),
pDrmFormatModifierProperties(nullptr)
{}
safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT(const safe_VkDrmFormatModifierPropertiesListEXT& copy_src)
{
sType = copy_src.sType;
drmFormatModifierCount = copy_src.drmFormatModifierCount;
pDrmFormatModifierProperties = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDrmFormatModifierProperties) {
pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src.drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifierProperties, (void *)copy_src.pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*copy_src.drmFormatModifierCount);
}
}
safe_VkDrmFormatModifierPropertiesListEXT& safe_VkDrmFormatModifierPropertiesListEXT::operator=(const safe_VkDrmFormatModifierPropertiesListEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pDrmFormatModifierProperties)
delete[] pDrmFormatModifierProperties;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
drmFormatModifierCount = copy_src.drmFormatModifierCount;
pDrmFormatModifierProperties = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDrmFormatModifierProperties) {
pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src.drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifierProperties, (void *)copy_src.pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*copy_src.drmFormatModifierCount);
}
return *this;
}
safe_VkDrmFormatModifierPropertiesListEXT::~safe_VkDrmFormatModifierPropertiesListEXT()
{
if (pDrmFormatModifierProperties)
delete[] pDrmFormatModifierProperties;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct)
{
sType = in_struct->sType;
drmFormatModifierCount = in_struct->drmFormatModifierCount;
pDrmFormatModifierProperties = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDrmFormatModifierProperties) {
pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[in_struct->drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifierProperties, (void *)in_struct->pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*in_struct->drmFormatModifierCount);
}
}
void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const safe_VkDrmFormatModifierPropertiesListEXT* copy_src)
{
sType = copy_src->sType;
drmFormatModifierCount = copy_src->drmFormatModifierCount;
pDrmFormatModifierProperties = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDrmFormatModifierProperties) {
pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src->drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifierProperties, (void *)copy_src->pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*copy_src->drmFormatModifierCount);
}
}
safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct) :
sType(in_struct->sType),
drmFormatModifier(in_struct->drmFormatModifier),
sharingMode(in_struct->sharingMode),
queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
pQueueFamilyIndices(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
}
}
safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT),
pNext(nullptr),
pQueueFamilyIndices(nullptr)
{}
safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src)
{
sType = copy_src.sType;
drmFormatModifier = copy_src.drmFormatModifier;
sharingMode = copy_src.sharingMode;
queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src.pQueueFamilyIndices, sizeof(uint32_t)*copy_src.queueFamilyIndexCount);
}
}
safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::operator=(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pQueueFamilyIndices)
delete[] pQueueFamilyIndices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
drmFormatModifier = copy_src.drmFormatModifier;
sharingMode = copy_src.sharingMode;
queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src.pQueueFamilyIndices, sizeof(uint32_t)*copy_src.queueFamilyIndexCount);
}
return *this;
}
safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::~safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT()
{
if (pQueueFamilyIndices)
delete[] pQueueFamilyIndices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct)
{
sType = in_struct->sType;
drmFormatModifier = in_struct->drmFormatModifier;
sharingMode = in_struct->sharingMode;
queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
}
}
void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* copy_src)
{
sType = copy_src->sType;
drmFormatModifier = copy_src->drmFormatModifier;
sharingMode = copy_src->sharingMode;
queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
pQueueFamilyIndices = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
memcpy ((void *)pQueueFamilyIndices, (void *)copy_src->pQueueFamilyIndices, sizeof(uint32_t)*copy_src->queueFamilyIndexCount);
}
}
safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct) :
sType(in_struct->sType),
drmFormatModifierCount(in_struct->drmFormatModifierCount),
pDrmFormatModifiers(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDrmFormatModifiers) {
pDrmFormatModifiers = new uint64_t[in_struct->drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifiers, (void *)in_struct->pDrmFormatModifiers, sizeof(uint64_t)*in_struct->drmFormatModifierCount);
}
}
safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT),
pNext(nullptr),
pDrmFormatModifiers(nullptr)
{}
safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT(const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
drmFormatModifierCount = copy_src.drmFormatModifierCount;
pDrmFormatModifiers = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDrmFormatModifiers) {
pDrmFormatModifiers = new uint64_t[copy_src.drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifiers, (void *)copy_src.pDrmFormatModifiers, sizeof(uint64_t)*copy_src.drmFormatModifierCount);
}
}
safe_VkImageDrmFormatModifierListCreateInfoEXT& safe_VkImageDrmFormatModifierListCreateInfoEXT::operator=(const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pDrmFormatModifiers)
delete[] pDrmFormatModifiers;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
drmFormatModifierCount = copy_src.drmFormatModifierCount;
pDrmFormatModifiers = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDrmFormatModifiers) {
pDrmFormatModifiers = new uint64_t[copy_src.drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifiers, (void *)copy_src.pDrmFormatModifiers, sizeof(uint64_t)*copy_src.drmFormatModifierCount);
}
return *this;
}
safe_VkImageDrmFormatModifierListCreateInfoEXT::~safe_VkImageDrmFormatModifierListCreateInfoEXT()
{
if (pDrmFormatModifiers)
delete[] pDrmFormatModifiers;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
drmFormatModifierCount = in_struct->drmFormatModifierCount;
pDrmFormatModifiers = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDrmFormatModifiers) {
pDrmFormatModifiers = new uint64_t[in_struct->drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifiers, (void *)in_struct->pDrmFormatModifiers, sizeof(uint64_t)*in_struct->drmFormatModifierCount);
}
}
void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const safe_VkImageDrmFormatModifierListCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
drmFormatModifierCount = copy_src->drmFormatModifierCount;
pDrmFormatModifiers = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDrmFormatModifiers) {
pDrmFormatModifiers = new uint64_t[copy_src->drmFormatModifierCount];
memcpy ((void *)pDrmFormatModifiers, (void *)copy_src->pDrmFormatModifiers, sizeof(uint64_t)*copy_src->drmFormatModifierCount);
}
}
safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct) :
sType(in_struct->sType),
drmFormatModifier(in_struct->drmFormatModifier),
drmFormatModifierPlaneCount(in_struct->drmFormatModifierPlaneCount),
pPlaneLayouts(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPlaneLayouts) {
pPlaneLayouts = new VkSubresourceLayout[in_struct->drmFormatModifierPlaneCount];
memcpy ((void *)pPlaneLayouts, (void *)in_struct->pPlaneLayouts, sizeof(VkSubresourceLayout)*in_struct->drmFormatModifierPlaneCount);
}
}
safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT),
pNext(nullptr),
pPlaneLayouts(nullptr)
{}
safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
drmFormatModifier = copy_src.drmFormatModifier;
drmFormatModifierPlaneCount = copy_src.drmFormatModifierPlaneCount;
pPlaneLayouts = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPlaneLayouts) {
pPlaneLayouts = new VkSubresourceLayout[copy_src.drmFormatModifierPlaneCount];
memcpy ((void *)pPlaneLayouts, (void *)copy_src.pPlaneLayouts, sizeof(VkSubresourceLayout)*copy_src.drmFormatModifierPlaneCount);
}
}
safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::operator=(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pPlaneLayouts)
delete[] pPlaneLayouts;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
drmFormatModifier = copy_src.drmFormatModifier;
drmFormatModifierPlaneCount = copy_src.drmFormatModifierPlaneCount;
pPlaneLayouts = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPlaneLayouts) {
pPlaneLayouts = new VkSubresourceLayout[copy_src.drmFormatModifierPlaneCount];
memcpy ((void *)pPlaneLayouts, (void *)copy_src.pPlaneLayouts, sizeof(VkSubresourceLayout)*copy_src.drmFormatModifierPlaneCount);
}
return *this;
}
safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::~safe_VkImageDrmFormatModifierExplicitCreateInfoEXT()
{
if (pPlaneLayouts)
delete[] pPlaneLayouts;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
drmFormatModifier = in_struct->drmFormatModifier;
drmFormatModifierPlaneCount = in_struct->drmFormatModifierPlaneCount;
pPlaneLayouts = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPlaneLayouts) {
pPlaneLayouts = new VkSubresourceLayout[in_struct->drmFormatModifierPlaneCount];
memcpy ((void *)pPlaneLayouts, (void *)in_struct->pPlaneLayouts, sizeof(VkSubresourceLayout)*in_struct->drmFormatModifierPlaneCount);
}
}
void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
drmFormatModifier = copy_src->drmFormatModifier;
drmFormatModifierPlaneCount = copy_src->drmFormatModifierPlaneCount;
pPlaneLayouts = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pPlaneLayouts) {
pPlaneLayouts = new VkSubresourceLayout[copy_src->drmFormatModifierPlaneCount];
memcpy ((void *)pPlaneLayouts, (void *)copy_src->pPlaneLayouts, sizeof(VkSubresourceLayout)*copy_src->drmFormatModifierPlaneCount);
}
}
safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT* in_struct) :
sType(in_struct->sType),
drmFormatModifier(in_struct->drmFormatModifier)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT(const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src)
{
sType = copy_src.sType;
drmFormatModifier = copy_src.drmFormatModifier;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImageDrmFormatModifierPropertiesEXT& safe_VkImageDrmFormatModifierPropertiesEXT::operator=(const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
drmFormatModifier = copy_src.drmFormatModifier;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImageDrmFormatModifierPropertiesEXT::~safe_VkImageDrmFormatModifierPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImageDrmFormatModifierPropertiesEXT::initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct)
{
sType = in_struct->sType;
drmFormatModifier = in_struct->drmFormatModifier;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImageDrmFormatModifierPropertiesEXT::initialize(const safe_VkImageDrmFormatModifierPropertiesEXT* copy_src)
{
sType = copy_src->sType;
drmFormatModifier = copy_src->drmFormatModifier;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
initialDataSize(in_struct->initialDataSize),
pInitialData(in_struct->pInitialData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT),
pNext(nullptr),
pInitialData(nullptr)
{}
safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT(const safe_VkValidationCacheCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
initialDataSize = copy_src.initialDataSize;
pInitialData = copy_src.pInitialData;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkValidationCacheCreateInfoEXT& safe_VkValidationCacheCreateInfoEXT::operator=(const safe_VkValidationCacheCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
initialDataSize = copy_src.initialDataSize;
pInitialData = copy_src.pInitialData;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkValidationCacheCreateInfoEXT::~safe_VkValidationCacheCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkValidationCacheCreateInfoEXT::initialize(const VkValidationCacheCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
initialDataSize = in_struct->initialDataSize;
pInitialData = in_struct->pInitialData;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkValidationCacheCreateInfoEXT::initialize(const safe_VkValidationCacheCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
initialDataSize = copy_src->initialDataSize;
pInitialData = copy_src->pInitialData;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct) :
sType(in_struct->sType),
validationCache(in_struct->validationCache)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT(const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
validationCache = copy_src.validationCache;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkShaderModuleValidationCacheCreateInfoEXT& safe_VkShaderModuleValidationCacheCreateInfoEXT::operator=(const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
validationCache = copy_src.validationCache;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkShaderModuleValidationCacheCreateInfoEXT::~safe_VkShaderModuleValidationCacheCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkShaderModuleValidationCacheCreateInfoEXT::initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
validationCache = in_struct->validationCache;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkShaderModuleValidationCacheCreateInfoEXT::initialize(const safe_VkShaderModuleValidationCacheCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
validationCache = copy_src->validationCache;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct) :
shadingRatePaletteEntryCount(in_struct->shadingRatePaletteEntryCount),
pShadingRatePaletteEntries(nullptr)
{
if (in_struct->pShadingRatePaletteEntries) {
pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[in_struct->shadingRatePaletteEntryCount];
memcpy ((void *)pShadingRatePaletteEntries, (void *)in_struct->pShadingRatePaletteEntries, sizeof(VkShadingRatePaletteEntryNV)*in_struct->shadingRatePaletteEntryCount);
}
}
safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV() :
pShadingRatePaletteEntries(nullptr)
{}
safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV(const safe_VkShadingRatePaletteNV& copy_src)
{
shadingRatePaletteEntryCount = copy_src.shadingRatePaletteEntryCount;
pShadingRatePaletteEntries = nullptr;
if (copy_src.pShadingRatePaletteEntries) {
pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src.shadingRatePaletteEntryCount];
memcpy ((void *)pShadingRatePaletteEntries, (void *)copy_src.pShadingRatePaletteEntries, sizeof(VkShadingRatePaletteEntryNV)*copy_src.shadingRatePaletteEntryCount);
}
}
safe_VkShadingRatePaletteNV& safe_VkShadingRatePaletteNV::operator=(const safe_VkShadingRatePaletteNV& copy_src)
{
if (&copy_src == this) return *this;
if (pShadingRatePaletteEntries)
delete[] pShadingRatePaletteEntries;
shadingRatePaletteEntryCount = copy_src.shadingRatePaletteEntryCount;
pShadingRatePaletteEntries = nullptr;
if (copy_src.pShadingRatePaletteEntries) {
pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src.shadingRatePaletteEntryCount];
memcpy ((void *)pShadingRatePaletteEntries, (void *)copy_src.pShadingRatePaletteEntries, sizeof(VkShadingRatePaletteEntryNV)*copy_src.shadingRatePaletteEntryCount);
}
return *this;
}
safe_VkShadingRatePaletteNV::~safe_VkShadingRatePaletteNV()
{
if (pShadingRatePaletteEntries)
delete[] pShadingRatePaletteEntries;
}
void safe_VkShadingRatePaletteNV::initialize(const VkShadingRatePaletteNV* in_struct)
{
shadingRatePaletteEntryCount = in_struct->shadingRatePaletteEntryCount;
pShadingRatePaletteEntries = nullptr;
if (in_struct->pShadingRatePaletteEntries) {
pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[in_struct->shadingRatePaletteEntryCount];
memcpy ((void *)pShadingRatePaletteEntries, (void *)in_struct->pShadingRatePaletteEntries, sizeof(VkShadingRatePaletteEntryNV)*in_struct->shadingRatePaletteEntryCount);
}
}
void safe_VkShadingRatePaletteNV::initialize(const safe_VkShadingRatePaletteNV* copy_src)
{
shadingRatePaletteEntryCount = copy_src->shadingRatePaletteEntryCount;
pShadingRatePaletteEntries = nullptr;
if (copy_src->pShadingRatePaletteEntries) {
pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src->shadingRatePaletteEntryCount];
memcpy ((void *)pShadingRatePaletteEntries, (void *)copy_src->pShadingRatePaletteEntries, sizeof(VkShadingRatePaletteEntryNV)*copy_src->shadingRatePaletteEntryCount);
}
}
safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
shadingRateImageEnable(in_struct->shadingRateImageEnable),
viewportCount(in_struct->viewportCount),
pShadingRatePalettes(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (viewportCount && in_struct->pShadingRatePalettes) {
pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
for (uint32_t i = 0; i < viewportCount; ++i) {
pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]);
}
}
}
safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV),
pNext(nullptr),
pShadingRatePalettes(nullptr)
{}
safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
shadingRateImageEnable = copy_src.shadingRateImageEnable;
viewportCount = copy_src.viewportCount;
pShadingRatePalettes = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (viewportCount && copy_src.pShadingRatePalettes) {
pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
for (uint32_t i = 0; i < viewportCount; ++i) {
pShadingRatePalettes[i].initialize(&copy_src.pShadingRatePalettes[i]);
}
}
}
safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::operator=(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pShadingRatePalettes)
delete[] pShadingRatePalettes;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shadingRateImageEnable = copy_src.shadingRateImageEnable;
viewportCount = copy_src.viewportCount;
pShadingRatePalettes = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (viewportCount && copy_src.pShadingRatePalettes) {
pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
for (uint32_t i = 0; i < viewportCount; ++i) {
pShadingRatePalettes[i].initialize(&copy_src.pShadingRatePalettes[i]);
}
}
return *this;
}
safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::~safe_VkPipelineViewportShadingRateImageStateCreateInfoNV()
{
if (pShadingRatePalettes)
delete[] pShadingRatePalettes;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
shadingRateImageEnable = in_struct->shadingRateImageEnable;
viewportCount = in_struct->viewportCount;
pShadingRatePalettes = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (viewportCount && in_struct->pShadingRatePalettes) {
pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
for (uint32_t i = 0; i < viewportCount; ++i) {
pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]);
}
}
}
void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
shadingRateImageEnable = copy_src->shadingRateImageEnable;
viewportCount = copy_src->viewportCount;
pShadingRatePalettes = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (viewportCount && copy_src->pShadingRatePalettes) {
pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
for (uint32_t i = 0; i < viewportCount; ++i) {
pShadingRatePalettes[i].initialize(&copy_src->pShadingRatePalettes[i]);
}
}
}
safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct) :
sType(in_struct->sType),
shadingRateImage(in_struct->shadingRateImage),
shadingRateCoarseSampleOrder(in_struct->shadingRateCoarseSampleOrder)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src)
{
sType = copy_src.sType;
shadingRateImage = copy_src.shadingRateImage;
shadingRateCoarseSampleOrder = copy_src.shadingRateCoarseSampleOrder;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShadingRateImageFeaturesNV& safe_VkPhysicalDeviceShadingRateImageFeaturesNV::operator=(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shadingRateImage = copy_src.shadingRateImage;
shadingRateCoarseSampleOrder = copy_src.shadingRateCoarseSampleOrder;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShadingRateImageFeaturesNV::~safe_VkPhysicalDeviceShadingRateImageFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShadingRateImageFeaturesNV::initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct)
{
sType = in_struct->sType;
shadingRateImage = in_struct->shadingRateImage;
shadingRateCoarseSampleOrder = in_struct->shadingRateCoarseSampleOrder;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShadingRateImageFeaturesNV::initialize(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV* copy_src)
{
sType = copy_src->sType;
shadingRateImage = copy_src->shadingRateImage;
shadingRateCoarseSampleOrder = copy_src->shadingRateCoarseSampleOrder;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct) :
sType(in_struct->sType),
shadingRateTexelSize(in_struct->shadingRateTexelSize),
shadingRatePaletteSize(in_struct->shadingRatePaletteSize),
shadingRateMaxCoarseSamples(in_struct->shadingRateMaxCoarseSamples)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src)
{
sType = copy_src.sType;
shadingRateTexelSize = copy_src.shadingRateTexelSize;
shadingRatePaletteSize = copy_src.shadingRatePaletteSize;
shadingRateMaxCoarseSamples = copy_src.shadingRateMaxCoarseSamples;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShadingRateImagePropertiesNV& safe_VkPhysicalDeviceShadingRateImagePropertiesNV::operator=(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shadingRateTexelSize = copy_src.shadingRateTexelSize;
shadingRatePaletteSize = copy_src.shadingRatePaletteSize;
shadingRateMaxCoarseSamples = copy_src.shadingRateMaxCoarseSamples;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShadingRateImagePropertiesNV::~safe_VkPhysicalDeviceShadingRateImagePropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShadingRateImagePropertiesNV::initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct)
{
sType = in_struct->sType;
shadingRateTexelSize = in_struct->shadingRateTexelSize;
shadingRatePaletteSize = in_struct->shadingRatePaletteSize;
shadingRateMaxCoarseSamples = in_struct->shadingRateMaxCoarseSamples;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShadingRateImagePropertiesNV::initialize(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV* copy_src)
{
sType = copy_src->sType;
shadingRateTexelSize = copy_src->shadingRateTexelSize;
shadingRatePaletteSize = copy_src->shadingRatePaletteSize;
shadingRateMaxCoarseSamples = copy_src->shadingRateMaxCoarseSamples;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct) :
shadingRate(in_struct->shadingRate),
sampleCount(in_struct->sampleCount),
sampleLocationCount(in_struct->sampleLocationCount),
pSampleLocations(nullptr)
{
if (in_struct->pSampleLocations) {
pSampleLocations = new VkCoarseSampleLocationNV[in_struct->sampleLocationCount];
memcpy ((void *)pSampleLocations, (void *)in_struct->pSampleLocations, sizeof(VkCoarseSampleLocationNV)*in_struct->sampleLocationCount);
}
}
safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV() :
pSampleLocations(nullptr)
{}
safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV(const safe_VkCoarseSampleOrderCustomNV& copy_src)
{
shadingRate = copy_src.shadingRate;
sampleCount = copy_src.sampleCount;
sampleLocationCount = copy_src.sampleLocationCount;
pSampleLocations = nullptr;
if (copy_src.pSampleLocations) {
pSampleLocations = new VkCoarseSampleLocationNV[copy_src.sampleLocationCount];
memcpy ((void *)pSampleLocations, (void *)copy_src.pSampleLocations, sizeof(VkCoarseSampleLocationNV)*copy_src.sampleLocationCount);
}
}
safe_VkCoarseSampleOrderCustomNV& safe_VkCoarseSampleOrderCustomNV::operator=(const safe_VkCoarseSampleOrderCustomNV& copy_src)
{
if (&copy_src == this) return *this;
if (pSampleLocations)
delete[] pSampleLocations;
shadingRate = copy_src.shadingRate;
sampleCount = copy_src.sampleCount;
sampleLocationCount = copy_src.sampleLocationCount;
pSampleLocations = nullptr;
if (copy_src.pSampleLocations) {
pSampleLocations = new VkCoarseSampleLocationNV[copy_src.sampleLocationCount];
memcpy ((void *)pSampleLocations, (void *)copy_src.pSampleLocations, sizeof(VkCoarseSampleLocationNV)*copy_src.sampleLocationCount);
}
return *this;
}
safe_VkCoarseSampleOrderCustomNV::~safe_VkCoarseSampleOrderCustomNV()
{
if (pSampleLocations)
delete[] pSampleLocations;
}
void safe_VkCoarseSampleOrderCustomNV::initialize(const VkCoarseSampleOrderCustomNV* in_struct)
{
shadingRate = in_struct->shadingRate;
sampleCount = in_struct->sampleCount;
sampleLocationCount = in_struct->sampleLocationCount;
pSampleLocations = nullptr;
if (in_struct->pSampleLocations) {
pSampleLocations = new VkCoarseSampleLocationNV[in_struct->sampleLocationCount];
memcpy ((void *)pSampleLocations, (void *)in_struct->pSampleLocations, sizeof(VkCoarseSampleLocationNV)*in_struct->sampleLocationCount);
}
}
void safe_VkCoarseSampleOrderCustomNV::initialize(const safe_VkCoarseSampleOrderCustomNV* copy_src)
{
shadingRate = copy_src->shadingRate;
sampleCount = copy_src->sampleCount;
sampleLocationCount = copy_src->sampleLocationCount;
pSampleLocations = nullptr;
if (copy_src->pSampleLocations) {
pSampleLocations = new VkCoarseSampleLocationNV[copy_src->sampleLocationCount];
memcpy ((void *)pSampleLocations, (void *)copy_src->pSampleLocations, sizeof(VkCoarseSampleLocationNV)*copy_src->sampleLocationCount);
}
}
safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
sampleOrderType(in_struct->sampleOrderType),
customSampleOrderCount(in_struct->customSampleOrderCount),
pCustomSampleOrders(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (customSampleOrderCount && in_struct->pCustomSampleOrders) {
pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]);
}
}
}
safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV),
pNext(nullptr),
pCustomSampleOrders(nullptr)
{}
safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
sampleOrderType = copy_src.sampleOrderType;
customSampleOrderCount = copy_src.customSampleOrderCount;
pCustomSampleOrders = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (customSampleOrderCount && copy_src.pCustomSampleOrders) {
pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
pCustomSampleOrders[i].initialize(&copy_src.pCustomSampleOrders[i]);
}
}
}
safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pCustomSampleOrders)
delete[] pCustomSampleOrders;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
sampleOrderType = copy_src.sampleOrderType;
customSampleOrderCount = copy_src.customSampleOrderCount;
pCustomSampleOrders = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (customSampleOrderCount && copy_src.pCustomSampleOrders) {
pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
pCustomSampleOrders[i].initialize(&copy_src.pCustomSampleOrders[i]);
}
}
return *this;
}
safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::~safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV()
{
if (pCustomSampleOrders)
delete[] pCustomSampleOrders;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
sampleOrderType = in_struct->sampleOrderType;
customSampleOrderCount = in_struct->customSampleOrderCount;
pCustomSampleOrders = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (customSampleOrderCount && in_struct->pCustomSampleOrders) {
pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]);
}
}
}
void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
sampleOrderType = copy_src->sampleOrderType;
customSampleOrderCount = copy_src->customSampleOrderCount;
pCustomSampleOrders = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (customSampleOrderCount && copy_src->pCustomSampleOrders) {
pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
pCustomSampleOrders[i].initialize(&copy_src->pCustomSampleOrders[i]);
}
}
}
safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV* in_struct) :
sType(in_struct->sType),
type(in_struct->type),
generalShader(in_struct->generalShader),
closestHitShader(in_struct->closestHitShader),
anyHitShader(in_struct->anyHitShader),
intersectionShader(in_struct->intersectionShader)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV(const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src)
{
sType = copy_src.sType;
type = copy_src.type;
generalShader = copy_src.generalShader;
closestHitShader = copy_src.closestHitShader;
anyHitShader = copy_src.anyHitShader;
intersectionShader = copy_src.intersectionShader;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkRayTracingShaderGroupCreateInfoNV& safe_VkRayTracingShaderGroupCreateInfoNV::operator=(const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
type = copy_src.type;
generalShader = copy_src.generalShader;
closestHitShader = copy_src.closestHitShader;
anyHitShader = copy_src.anyHitShader;
intersectionShader = copy_src.intersectionShader;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkRayTracingShaderGroupCreateInfoNV::~safe_VkRayTracingShaderGroupCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRayTracingShaderGroupCreateInfoNV::initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct)
{
sType = in_struct->sType;
type = in_struct->type;
generalShader = in_struct->generalShader;
closestHitShader = in_struct->closestHitShader;
anyHitShader = in_struct->anyHitShader;
intersectionShader = in_struct->intersectionShader;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkRayTracingShaderGroupCreateInfoNV::initialize(const safe_VkRayTracingShaderGroupCreateInfoNV* copy_src)
{
sType = copy_src->sType;
type = copy_src->type;
generalShader = copy_src->generalShader;
closestHitShader = copy_src->closestHitShader;
anyHitShader = copy_src->anyHitShader;
intersectionShader = copy_src->intersectionShader;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
stageCount(in_struct->stageCount),
pStages(nullptr),
groupCount(in_struct->groupCount),
pGroups(nullptr),
maxRecursionDepth(in_struct->maxRecursionDepth),
layout(in_struct->layout),
basePipelineHandle(in_struct->basePipelineHandle),
basePipelineIndex(in_struct->basePipelineIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
if (stageCount && in_struct->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&in_struct->pStages[i]);
}
}
if (groupCount && in_struct->pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&in_struct->pGroups[i]);
}
}
}
safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV),
pNext(nullptr),
pStages(nullptr),
pGroups(nullptr)
{}
safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(const safe_VkRayTracingPipelineCreateInfoNV& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
stageCount = copy_src.stageCount;
pStages = nullptr;
groupCount = copy_src.groupCount;
pGroups = nullptr;
maxRecursionDepth = copy_src.maxRecursionDepth;
layout = copy_src.layout;
basePipelineHandle = copy_src.basePipelineHandle;
basePipelineIndex = copy_src.basePipelineIndex;
pNext = SafePnextCopy(copy_src.pNext);
if (stageCount && copy_src.pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src.pStages[i]);
}
}
if (groupCount && copy_src.pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src.pGroups[i]);
}
}
}
safe_VkRayTracingPipelineCreateInfoNV& safe_VkRayTracingPipelineCreateInfoNV::operator=(const safe_VkRayTracingPipelineCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pStages)
delete[] pStages;
if (pGroups)
delete[] pGroups;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
stageCount = copy_src.stageCount;
pStages = nullptr;
groupCount = copy_src.groupCount;
pGroups = nullptr;
maxRecursionDepth = copy_src.maxRecursionDepth;
layout = copy_src.layout;
basePipelineHandle = copy_src.basePipelineHandle;
basePipelineIndex = copy_src.basePipelineIndex;
pNext = SafePnextCopy(copy_src.pNext);
if (stageCount && copy_src.pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src.pStages[i]);
}
}
if (groupCount && copy_src.pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src.pGroups[i]);
}
}
return *this;
}
safe_VkRayTracingPipelineCreateInfoNV::~safe_VkRayTracingPipelineCreateInfoNV()
{
if (pStages)
delete[] pStages;
if (pGroups)
delete[] pGroups;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRayTracingPipelineCreateInfoNV::initialize(const VkRayTracingPipelineCreateInfoNV* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
stageCount = in_struct->stageCount;
pStages = nullptr;
groupCount = in_struct->groupCount;
pGroups = nullptr;
maxRecursionDepth = in_struct->maxRecursionDepth;
layout = in_struct->layout;
basePipelineHandle = in_struct->basePipelineHandle;
basePipelineIndex = in_struct->basePipelineIndex;
pNext = SafePnextCopy(in_struct->pNext);
if (stageCount && in_struct->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&in_struct->pStages[i]);
}
}
if (groupCount && in_struct->pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&in_struct->pGroups[i]);
}
}
}
void safe_VkRayTracingPipelineCreateInfoNV::initialize(const safe_VkRayTracingPipelineCreateInfoNV* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
stageCount = copy_src->stageCount;
pStages = nullptr;
groupCount = copy_src->groupCount;
pGroups = nullptr;
maxRecursionDepth = copy_src->maxRecursionDepth;
layout = copy_src->layout;
basePipelineHandle = copy_src->basePipelineHandle;
basePipelineIndex = copy_src->basePipelineIndex;
pNext = SafePnextCopy(copy_src->pNext);
if (stageCount && copy_src->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src->pStages[i]);
}
}
if (groupCount && copy_src->pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src->pGroups[i]);
}
}
}
safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct) :
sType(in_struct->sType),
vertexData(in_struct->vertexData),
vertexOffset(in_struct->vertexOffset),
vertexCount(in_struct->vertexCount),
vertexStride(in_struct->vertexStride),
vertexFormat(in_struct->vertexFormat),
indexData(in_struct->indexData),
indexOffset(in_struct->indexOffset),
indexCount(in_struct->indexCount),
indexType(in_struct->indexType),
transformData(in_struct->transformData),
transformOffset(in_struct->transformOffset)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV() :
sType(VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV),
pNext(nullptr)
{}
safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const safe_VkGeometryTrianglesNV& copy_src)
{
sType = copy_src.sType;
vertexData = copy_src.vertexData;
vertexOffset = copy_src.vertexOffset;
vertexCount = copy_src.vertexCount;
vertexStride = copy_src.vertexStride;
vertexFormat = copy_src.vertexFormat;
indexData = copy_src.indexData;
indexOffset = copy_src.indexOffset;
indexCount = copy_src.indexCount;
indexType = copy_src.indexType;
transformData = copy_src.transformData;
transformOffset = copy_src.transformOffset;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkGeometryTrianglesNV& safe_VkGeometryTrianglesNV::operator=(const safe_VkGeometryTrianglesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
vertexData = copy_src.vertexData;
vertexOffset = copy_src.vertexOffset;
vertexCount = copy_src.vertexCount;
vertexStride = copy_src.vertexStride;
vertexFormat = copy_src.vertexFormat;
indexData = copy_src.indexData;
indexOffset = copy_src.indexOffset;
indexCount = copy_src.indexCount;
indexType = copy_src.indexType;
transformData = copy_src.transformData;
transformOffset = copy_src.transformOffset;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkGeometryTrianglesNV::~safe_VkGeometryTrianglesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkGeometryTrianglesNV::initialize(const VkGeometryTrianglesNV* in_struct)
{
sType = in_struct->sType;
vertexData = in_struct->vertexData;
vertexOffset = in_struct->vertexOffset;
vertexCount = in_struct->vertexCount;
vertexStride = in_struct->vertexStride;
vertexFormat = in_struct->vertexFormat;
indexData = in_struct->indexData;
indexOffset = in_struct->indexOffset;
indexCount = in_struct->indexCount;
indexType = in_struct->indexType;
transformData = in_struct->transformData;
transformOffset = in_struct->transformOffset;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkGeometryTrianglesNV::initialize(const safe_VkGeometryTrianglesNV* copy_src)
{
sType = copy_src->sType;
vertexData = copy_src->vertexData;
vertexOffset = copy_src->vertexOffset;
vertexCount = copy_src->vertexCount;
vertexStride = copy_src->vertexStride;
vertexFormat = copy_src->vertexFormat;
indexData = copy_src->indexData;
indexOffset = copy_src->indexOffset;
indexCount = copy_src->indexCount;
indexType = copy_src->indexType;
transformData = copy_src->transformData;
transformOffset = copy_src->transformOffset;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkGeometryAABBNV::safe_VkGeometryAABBNV(const VkGeometryAABBNV* in_struct) :
sType(in_struct->sType),
aabbData(in_struct->aabbData),
numAABBs(in_struct->numAABBs),
stride(in_struct->stride),
offset(in_struct->offset)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkGeometryAABBNV::safe_VkGeometryAABBNV() :
sType(VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV),
pNext(nullptr)
{}
safe_VkGeometryAABBNV::safe_VkGeometryAABBNV(const safe_VkGeometryAABBNV& copy_src)
{
sType = copy_src.sType;
aabbData = copy_src.aabbData;
numAABBs = copy_src.numAABBs;
stride = copy_src.stride;
offset = copy_src.offset;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkGeometryAABBNV& safe_VkGeometryAABBNV::operator=(const safe_VkGeometryAABBNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
aabbData = copy_src.aabbData;
numAABBs = copy_src.numAABBs;
stride = copy_src.stride;
offset = copy_src.offset;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkGeometryAABBNV::~safe_VkGeometryAABBNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkGeometryAABBNV::initialize(const VkGeometryAABBNV* in_struct)
{
sType = in_struct->sType;
aabbData = in_struct->aabbData;
numAABBs = in_struct->numAABBs;
stride = in_struct->stride;
offset = in_struct->offset;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkGeometryAABBNV::initialize(const safe_VkGeometryAABBNV* copy_src)
{
sType = copy_src->sType;
aabbData = copy_src->aabbData;
numAABBs = copy_src->numAABBs;
stride = copy_src->stride;
offset = copy_src->offset;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkGeometryNV::safe_VkGeometryNV(const VkGeometryNV* in_struct) :
sType(in_struct->sType),
geometryType(in_struct->geometryType),
geometry(in_struct->geometry),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkGeometryNV::safe_VkGeometryNV() :
sType(VK_STRUCTURE_TYPE_GEOMETRY_NV),
pNext(nullptr)
{}
safe_VkGeometryNV::safe_VkGeometryNV(const safe_VkGeometryNV& copy_src)
{
sType = copy_src.sType;
geometryType = copy_src.geometryType;
geometry = copy_src.geometry;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkGeometryNV& safe_VkGeometryNV::operator=(const safe_VkGeometryNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
geometryType = copy_src.geometryType;
geometry = copy_src.geometry;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkGeometryNV::~safe_VkGeometryNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkGeometryNV::initialize(const VkGeometryNV* in_struct)
{
sType = in_struct->sType;
geometryType = in_struct->geometryType;
geometry = in_struct->geometry;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkGeometryNV::initialize(const safe_VkGeometryNV* copy_src)
{
sType = copy_src->sType;
geometryType = copy_src->geometryType;
geometry = copy_src->geometry;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct) :
sType(in_struct->sType),
type(in_struct->type),
flags(in_struct->flags),
instanceCount(in_struct->instanceCount),
geometryCount(in_struct->geometryCount),
pGeometries(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (geometryCount && in_struct->pGeometries) {
pGeometries = new safe_VkGeometryNV[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
pGeometries[i].initialize(&in_struct->pGeometries[i]);
}
}
}
safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV),
pNext(nullptr),
pGeometries(nullptr)
{}
safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV(const safe_VkAccelerationStructureInfoNV& copy_src)
{
sType = copy_src.sType;
type = copy_src.type;
flags = copy_src.flags;
instanceCount = copy_src.instanceCount;
geometryCount = copy_src.geometryCount;
pGeometries = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (geometryCount && copy_src.pGeometries) {
pGeometries = new safe_VkGeometryNV[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
pGeometries[i].initialize(&copy_src.pGeometries[i]);
}
}
}
safe_VkAccelerationStructureInfoNV& safe_VkAccelerationStructureInfoNV::operator=(const safe_VkAccelerationStructureInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pGeometries)
delete[] pGeometries;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
type = copy_src.type;
flags = copy_src.flags;
instanceCount = copy_src.instanceCount;
geometryCount = copy_src.geometryCount;
pGeometries = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (geometryCount && copy_src.pGeometries) {
pGeometries = new safe_VkGeometryNV[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
pGeometries[i].initialize(&copy_src.pGeometries[i]);
}
}
return *this;
}
safe_VkAccelerationStructureInfoNV::~safe_VkAccelerationStructureInfoNV()
{
if (pGeometries)
delete[] pGeometries;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureInfoNV::initialize(const VkAccelerationStructureInfoNV* in_struct)
{
sType = in_struct->sType;
type = in_struct->type;
flags = in_struct->flags;
instanceCount = in_struct->instanceCount;
geometryCount = in_struct->geometryCount;
pGeometries = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (geometryCount && in_struct->pGeometries) {
pGeometries = new safe_VkGeometryNV[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
pGeometries[i].initialize(&in_struct->pGeometries[i]);
}
}
}
void safe_VkAccelerationStructureInfoNV::initialize(const safe_VkAccelerationStructureInfoNV* copy_src)
{
sType = copy_src->sType;
type = copy_src->type;
flags = copy_src->flags;
instanceCount = copy_src->instanceCount;
geometryCount = copy_src->geometryCount;
pGeometries = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (geometryCount && copy_src->pGeometries) {
pGeometries = new safe_VkGeometryNV[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
pGeometries[i].initialize(&copy_src->pGeometries[i]);
}
}
}
safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV* in_struct) :
sType(in_struct->sType),
compactedSize(in_struct->compactedSize),
info(&in_struct->info)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV(const safe_VkAccelerationStructureCreateInfoNV& copy_src)
{
sType = copy_src.sType;
compactedSize = copy_src.compactedSize;
info.initialize(&copy_src.info);
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureCreateInfoNV& safe_VkAccelerationStructureCreateInfoNV::operator=(const safe_VkAccelerationStructureCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
compactedSize = copy_src.compactedSize;
info.initialize(&copy_src.info);
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureCreateInfoNV::~safe_VkAccelerationStructureCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureCreateInfoNV::initialize(const VkAccelerationStructureCreateInfoNV* in_struct)
{
sType = in_struct->sType;
compactedSize = in_struct->compactedSize;
info.initialize(&in_struct->info);
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureCreateInfoNV::initialize(const safe_VkAccelerationStructureCreateInfoNV* copy_src)
{
sType = copy_src->sType;
compactedSize = copy_src->compactedSize;
info.initialize(&copy_src->info);
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV* in_struct) :
sType(in_struct->sType),
accelerationStructure(in_struct->accelerationStructure),
memory(in_struct->memory),
memoryOffset(in_struct->memoryOffset),
deviceIndexCount(in_struct->deviceIndexCount),
pDeviceIndices(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceIndices) {
pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
}
}
safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV() :
sType(VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV),
pNext(nullptr),
pDeviceIndices(nullptr)
{}
safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV(const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src)
{
sType = copy_src.sType;
accelerationStructure = copy_src.accelerationStructure;
memory = copy_src.memory;
memoryOffset = copy_src.memoryOffset;
deviceIndexCount = copy_src.deviceIndexCount;
pDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src.pDeviceIndices, sizeof(uint32_t)*copy_src.deviceIndexCount);
}
}
safe_VkBindAccelerationStructureMemoryInfoNV& safe_VkBindAccelerationStructureMemoryInfoNV::operator=(const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pDeviceIndices)
delete[] pDeviceIndices;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
accelerationStructure = copy_src.accelerationStructure;
memory = copy_src.memory;
memoryOffset = copy_src.memoryOffset;
deviceIndexCount = copy_src.deviceIndexCount;
pDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src.pDeviceIndices, sizeof(uint32_t)*copy_src.deviceIndexCount);
}
return *this;
}
safe_VkBindAccelerationStructureMemoryInfoNV::~safe_VkBindAccelerationStructureMemoryInfoNV()
{
if (pDeviceIndices)
delete[] pDeviceIndices;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const VkBindAccelerationStructureMemoryInfoNV* in_struct)
{
sType = in_struct->sType;
accelerationStructure = in_struct->accelerationStructure;
memory = in_struct->memory;
memoryOffset = in_struct->memoryOffset;
deviceIndexCount = in_struct->deviceIndexCount;
pDeviceIndices = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pDeviceIndices) {
pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
}
}
void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const safe_VkBindAccelerationStructureMemoryInfoNV* copy_src)
{
sType = copy_src->sType;
accelerationStructure = copy_src->accelerationStructure;
memory = copy_src->memory;
memoryOffset = copy_src->memoryOffset;
deviceIndexCount = copy_src->deviceIndexCount;
pDeviceIndices = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pDeviceIndices) {
pDeviceIndices = new uint32_t[copy_src->deviceIndexCount];
memcpy ((void *)pDeviceIndices, (void *)copy_src->pDeviceIndices, sizeof(uint32_t)*copy_src->deviceIndexCount);
}
}
safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV* in_struct) :
sType(in_struct->sType),
accelerationStructureCount(in_struct->accelerationStructureCount),
pAccelerationStructures(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (accelerationStructureCount && in_struct->pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
}
}
}
safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV() :
sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV),
pNext(nullptr),
pAccelerationStructures(nullptr)
{}
safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV(const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src)
{
sType = copy_src.sType;
accelerationStructureCount = copy_src.accelerationStructureCount;
pAccelerationStructures = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (accelerationStructureCount && copy_src.pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = copy_src.pAccelerationStructures[i];
}
}
}
safe_VkWriteDescriptorSetAccelerationStructureNV& safe_VkWriteDescriptorSetAccelerationStructureNV::operator=(const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src)
{
if (&copy_src == this) return *this;
if (pAccelerationStructures)
delete[] pAccelerationStructures;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
accelerationStructureCount = copy_src.accelerationStructureCount;
pAccelerationStructures = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (accelerationStructureCount && copy_src.pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = copy_src.pAccelerationStructures[i];
}
}
return *this;
}
safe_VkWriteDescriptorSetAccelerationStructureNV::~safe_VkWriteDescriptorSetAccelerationStructureNV()
{
if (pAccelerationStructures)
delete[] pAccelerationStructures;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const VkWriteDescriptorSetAccelerationStructureNV* in_struct)
{
sType = in_struct->sType;
accelerationStructureCount = in_struct->accelerationStructureCount;
pAccelerationStructures = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (accelerationStructureCount && in_struct->pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
}
}
}
void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const safe_VkWriteDescriptorSetAccelerationStructureNV* copy_src)
{
sType = copy_src->sType;
accelerationStructureCount = copy_src->accelerationStructureCount;
pAccelerationStructures = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (accelerationStructureCount && copy_src->pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = copy_src->pAccelerationStructures[i];
}
}
}
safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct) :
sType(in_struct->sType),
type(in_struct->type),
accelerationStructure(in_struct->accelerationStructure)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV),
pNext(nullptr)
{}
safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src)
{
sType = copy_src.sType;
type = copy_src.type;
accelerationStructure = copy_src.accelerationStructure;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureMemoryRequirementsInfoNV& safe_VkAccelerationStructureMemoryRequirementsInfoNV::operator=(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
type = copy_src.type;
accelerationStructure = copy_src.accelerationStructure;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureMemoryRequirementsInfoNV::~safe_VkAccelerationStructureMemoryRequirementsInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureMemoryRequirementsInfoNV::initialize(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct)
{
sType = in_struct->sType;
type = in_struct->type;
accelerationStructure = in_struct->accelerationStructure;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureMemoryRequirementsInfoNV::initialize(const safe_VkAccelerationStructureMemoryRequirementsInfoNV* copy_src)
{
sType = copy_src->sType;
type = copy_src->type;
accelerationStructure = copy_src->accelerationStructure;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct) :
sType(in_struct->sType),
shaderGroupHandleSize(in_struct->shaderGroupHandleSize),
maxRecursionDepth(in_struct->maxRecursionDepth),
maxShaderGroupStride(in_struct->maxShaderGroupStride),
shaderGroupBaseAlignment(in_struct->shaderGroupBaseAlignment),
maxGeometryCount(in_struct->maxGeometryCount),
maxInstanceCount(in_struct->maxInstanceCount),
maxTriangleCount(in_struct->maxTriangleCount),
maxDescriptorSetAccelerationStructures(in_struct->maxDescriptorSetAccelerationStructures)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV(const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src)
{
sType = copy_src.sType;
shaderGroupHandleSize = copy_src.shaderGroupHandleSize;
maxRecursionDepth = copy_src.maxRecursionDepth;
maxShaderGroupStride = copy_src.maxShaderGroupStride;
shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment;
maxGeometryCount = copy_src.maxGeometryCount;
maxInstanceCount = copy_src.maxInstanceCount;
maxTriangleCount = copy_src.maxTriangleCount;
maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceRayTracingPropertiesNV& safe_VkPhysicalDeviceRayTracingPropertiesNV::operator=(const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderGroupHandleSize = copy_src.shaderGroupHandleSize;
maxRecursionDepth = copy_src.maxRecursionDepth;
maxShaderGroupStride = copy_src.maxShaderGroupStride;
shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment;
maxGeometryCount = copy_src.maxGeometryCount;
maxInstanceCount = copy_src.maxInstanceCount;
maxTriangleCount = copy_src.maxTriangleCount;
maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceRayTracingPropertiesNV::~safe_VkPhysicalDeviceRayTracingPropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct)
{
sType = in_struct->sType;
shaderGroupHandleSize = in_struct->shaderGroupHandleSize;
maxRecursionDepth = in_struct->maxRecursionDepth;
maxShaderGroupStride = in_struct->maxShaderGroupStride;
shaderGroupBaseAlignment = in_struct->shaderGroupBaseAlignment;
maxGeometryCount = in_struct->maxGeometryCount;
maxInstanceCount = in_struct->maxInstanceCount;
maxTriangleCount = in_struct->maxTriangleCount;
maxDescriptorSetAccelerationStructures = in_struct->maxDescriptorSetAccelerationStructures;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const safe_VkPhysicalDeviceRayTracingPropertiesNV* copy_src)
{
sType = copy_src->sType;
shaderGroupHandleSize = copy_src->shaderGroupHandleSize;
maxRecursionDepth = copy_src->maxRecursionDepth;
maxShaderGroupStride = copy_src->maxShaderGroupStride;
shaderGroupBaseAlignment = copy_src->shaderGroupBaseAlignment;
maxGeometryCount = copy_src->maxGeometryCount;
maxInstanceCount = copy_src->maxInstanceCount;
maxTriangleCount = copy_src->maxTriangleCount;
maxDescriptorSetAccelerationStructures = copy_src->maxDescriptorSetAccelerationStructures;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct) :
sType(in_struct->sType),
representativeFragmentTest(in_struct->representativeFragmentTest)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src)
{
sType = copy_src.sType;
representativeFragmentTest = copy_src.representativeFragmentTest;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
representativeFragmentTest = copy_src.representativeFragmentTest;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::~safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct)
{
sType = in_struct->sType;
representativeFragmentTest = in_struct->representativeFragmentTest;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* copy_src)
{
sType = copy_src->sType;
representativeFragmentTest = copy_src->representativeFragmentTest;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
representativeFragmentTestEnable(in_struct->representativeFragmentTestEnable)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
representativeFragmentTestEnable = copy_src.representativeFragmentTestEnable;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::operator=(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
representativeFragmentTestEnable = copy_src.representativeFragmentTestEnable;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::~safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::initialize(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
representativeFragmentTestEnable = in_struct->representativeFragmentTestEnable;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::initialize(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
representativeFragmentTestEnable = copy_src->representativeFragmentTestEnable;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct) :
sType(in_struct->sType),
imageViewType(in_struct->imageViewType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src)
{
sType = copy_src.sType;
imageViewType = copy_src.imageViewType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::operator=(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
imageViewType = copy_src.imageViewType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::~safe_VkPhysicalDeviceImageViewImageFormatInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct)
{
sType = in_struct->sType;
imageViewType = in_struct->imageViewType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::initialize(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT* copy_src)
{
sType = copy_src->sType;
imageViewType = copy_src->imageViewType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct) :
sType(in_struct->sType),
filterCubic(in_struct->filterCubic),
filterCubicMinmax(in_struct->filterCubicMinmax)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src)
{
sType = copy_src.sType;
filterCubic = copy_src.filterCubic;
filterCubicMinmax = copy_src.filterCubicMinmax;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkFilterCubicImageViewImageFormatPropertiesEXT& safe_VkFilterCubicImageViewImageFormatPropertiesEXT::operator=(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
filterCubic = copy_src.filterCubic;
filterCubicMinmax = copy_src.filterCubicMinmax;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkFilterCubicImageViewImageFormatPropertiesEXT::~safe_VkFilterCubicImageViewImageFormatPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFilterCubicImageViewImageFormatPropertiesEXT::initialize(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct)
{
sType = in_struct->sType;
filterCubic = in_struct->filterCubic;
filterCubicMinmax = in_struct->filterCubicMinmax;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkFilterCubicImageViewImageFormatPropertiesEXT::initialize(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT* copy_src)
{
sType = copy_src->sType;
filterCubic = copy_src->filterCubic;
filterCubicMinmax = copy_src->filterCubicMinmax;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT* in_struct) :
sType(in_struct->sType),
globalPriority(in_struct->globalPriority)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::safe_VkDeviceQueueGlobalPriorityCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
globalPriority = copy_src.globalPriority;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
globalPriority = copy_src.globalPriority;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::~safe_VkDeviceQueueGlobalPriorityCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::initialize(const VkDeviceQueueGlobalPriorityCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
globalPriority = in_struct->globalPriority;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
globalPriority = copy_src->globalPriority;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct) :
sType(in_struct->sType),
handleType(in_struct->handleType),
pHostPointer(in_struct->pHostPointer)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT() :
sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT),
pNext(nullptr),
pHostPointer(nullptr)
{}
safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT(const safe_VkImportMemoryHostPointerInfoEXT& copy_src)
{
sType = copy_src.sType;
handleType = copy_src.handleType;
pHostPointer = copy_src.pHostPointer;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportMemoryHostPointerInfoEXT& safe_VkImportMemoryHostPointerInfoEXT::operator=(const safe_VkImportMemoryHostPointerInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleType = copy_src.handleType;
pHostPointer = copy_src.pHostPointer;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportMemoryHostPointerInfoEXT::~safe_VkImportMemoryHostPointerInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportMemoryHostPointerInfoEXT::initialize(const VkImportMemoryHostPointerInfoEXT* in_struct)
{
sType = in_struct->sType;
handleType = in_struct->handleType;
pHostPointer = in_struct->pHostPointer;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportMemoryHostPointerInfoEXT::initialize(const safe_VkImportMemoryHostPointerInfoEXT* copy_src)
{
sType = copy_src->sType;
handleType = copy_src->handleType;
pHostPointer = copy_src->pHostPointer;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* in_struct) :
sType(in_struct->sType),
memoryTypeBits(in_struct->memoryTypeBits)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT(const safe_VkMemoryHostPointerPropertiesEXT& copy_src)
{
sType = copy_src.sType;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryHostPointerPropertiesEXT& safe_VkMemoryHostPointerPropertiesEXT::operator=(const safe_VkMemoryHostPointerPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryHostPointerPropertiesEXT::~safe_VkMemoryHostPointerPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryHostPointerPropertiesEXT::initialize(const VkMemoryHostPointerPropertiesEXT* in_struct)
{
sType = in_struct->sType;
memoryTypeBits = in_struct->memoryTypeBits;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryHostPointerPropertiesEXT::initialize(const safe_VkMemoryHostPointerPropertiesEXT* copy_src)
{
sType = copy_src->sType;
memoryTypeBits = copy_src->memoryTypeBits;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct) :
sType(in_struct->sType),
minImportedHostPointerAlignment(in_struct->minImportedHostPointerAlignment)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src)
{
sType = copy_src.sType;
minImportedHostPointerAlignment = copy_src.minImportedHostPointerAlignment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::operator=(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
minImportedHostPointerAlignment = copy_src.minImportedHostPointerAlignment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::~safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::initialize(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct)
{
sType = in_struct->sType;
minImportedHostPointerAlignment = in_struct->minImportedHostPointerAlignment;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::initialize(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* copy_src)
{
sType = copy_src->sType;
minImportedHostPointerAlignment = copy_src->minImportedHostPointerAlignment;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD* in_struct) :
sType(in_struct->sType),
compilerControlFlags(in_struct->compilerControlFlags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD() :
sType(VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD),
pNext(nullptr)
{}
safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD(const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src)
{
sType = copy_src.sType;
compilerControlFlags = copy_src.compilerControlFlags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineCompilerControlCreateInfoAMD& safe_VkPipelineCompilerControlCreateInfoAMD::operator=(const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
compilerControlFlags = copy_src.compilerControlFlags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineCompilerControlCreateInfoAMD::~safe_VkPipelineCompilerControlCreateInfoAMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineCompilerControlCreateInfoAMD::initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct)
{
sType = in_struct->sType;
compilerControlFlags = in_struct->compilerControlFlags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineCompilerControlCreateInfoAMD::initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* copy_src)
{
sType = copy_src->sType;
compilerControlFlags = copy_src->compilerControlFlags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCalibratedTimestampInfoEXT::safe_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT* in_struct) :
sType(in_struct->sType),
timeDomain(in_struct->timeDomain)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCalibratedTimestampInfoEXT::safe_VkCalibratedTimestampInfoEXT() :
sType(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT),
pNext(nullptr)
{}
safe_VkCalibratedTimestampInfoEXT::safe_VkCalibratedTimestampInfoEXT(const safe_VkCalibratedTimestampInfoEXT& copy_src)
{
sType = copy_src.sType;
timeDomain = copy_src.timeDomain;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCalibratedTimestampInfoEXT& safe_VkCalibratedTimestampInfoEXT::operator=(const safe_VkCalibratedTimestampInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
timeDomain = copy_src.timeDomain;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCalibratedTimestampInfoEXT::~safe_VkCalibratedTimestampInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCalibratedTimestampInfoEXT::initialize(const VkCalibratedTimestampInfoEXT* in_struct)
{
sType = in_struct->sType;
timeDomain = in_struct->timeDomain;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCalibratedTimestampInfoEXT::initialize(const safe_VkCalibratedTimestampInfoEXT* copy_src)
{
sType = copy_src->sType;
timeDomain = copy_src->timeDomain;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct) :
sType(in_struct->sType),
shaderEngineCount(in_struct->shaderEngineCount),
shaderArraysPerEngineCount(in_struct->shaderArraysPerEngineCount),
computeUnitsPerShaderArray(in_struct->computeUnitsPerShaderArray),
simdPerComputeUnit(in_struct->simdPerComputeUnit),
wavefrontsPerSimd(in_struct->wavefrontsPerSimd),
wavefrontSize(in_struct->wavefrontSize),
sgprsPerSimd(in_struct->sgprsPerSimd),
minSgprAllocation(in_struct->minSgprAllocation),
maxSgprAllocation(in_struct->maxSgprAllocation),
sgprAllocationGranularity(in_struct->sgprAllocationGranularity),
vgprsPerSimd(in_struct->vgprsPerSimd),
minVgprAllocation(in_struct->minVgprAllocation),
maxVgprAllocation(in_struct->maxVgprAllocation),
vgprAllocationGranularity(in_struct->vgprAllocationGranularity)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src)
{
sType = copy_src.sType;
shaderEngineCount = copy_src.shaderEngineCount;
shaderArraysPerEngineCount = copy_src.shaderArraysPerEngineCount;
computeUnitsPerShaderArray = copy_src.computeUnitsPerShaderArray;
simdPerComputeUnit = copy_src.simdPerComputeUnit;
wavefrontsPerSimd = copy_src.wavefrontsPerSimd;
wavefrontSize = copy_src.wavefrontSize;
sgprsPerSimd = copy_src.sgprsPerSimd;
minSgprAllocation = copy_src.minSgprAllocation;
maxSgprAllocation = copy_src.maxSgprAllocation;
sgprAllocationGranularity = copy_src.sgprAllocationGranularity;
vgprsPerSimd = copy_src.vgprsPerSimd;
minVgprAllocation = copy_src.minVgprAllocation;
maxVgprAllocation = copy_src.maxVgprAllocation;
vgprAllocationGranularity = copy_src.vgprAllocationGranularity;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderCorePropertiesAMD& safe_VkPhysicalDeviceShaderCorePropertiesAMD::operator=(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderEngineCount = copy_src.shaderEngineCount;
shaderArraysPerEngineCount = copy_src.shaderArraysPerEngineCount;
computeUnitsPerShaderArray = copy_src.computeUnitsPerShaderArray;
simdPerComputeUnit = copy_src.simdPerComputeUnit;
wavefrontsPerSimd = copy_src.wavefrontsPerSimd;
wavefrontSize = copy_src.wavefrontSize;
sgprsPerSimd = copy_src.sgprsPerSimd;
minSgprAllocation = copy_src.minSgprAllocation;
maxSgprAllocation = copy_src.maxSgprAllocation;
sgprAllocationGranularity = copy_src.sgprAllocationGranularity;
vgprsPerSimd = copy_src.vgprsPerSimd;
minVgprAllocation = copy_src.minVgprAllocation;
maxVgprAllocation = copy_src.maxVgprAllocation;
vgprAllocationGranularity = copy_src.vgprAllocationGranularity;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderCorePropertiesAMD::~safe_VkPhysicalDeviceShaderCorePropertiesAMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct)
{
sType = in_struct->sType;
shaderEngineCount = in_struct->shaderEngineCount;
shaderArraysPerEngineCount = in_struct->shaderArraysPerEngineCount;
computeUnitsPerShaderArray = in_struct->computeUnitsPerShaderArray;
simdPerComputeUnit = in_struct->simdPerComputeUnit;
wavefrontsPerSimd = in_struct->wavefrontsPerSimd;
wavefrontSize = in_struct->wavefrontSize;
sgprsPerSimd = in_struct->sgprsPerSimd;
minSgprAllocation = in_struct->minSgprAllocation;
maxSgprAllocation = in_struct->maxSgprAllocation;
sgprAllocationGranularity = in_struct->sgprAllocationGranularity;
vgprsPerSimd = in_struct->vgprsPerSimd;
minVgprAllocation = in_struct->minVgprAllocation;
maxVgprAllocation = in_struct->maxVgprAllocation;
vgprAllocationGranularity = in_struct->vgprAllocationGranularity;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const safe_VkPhysicalDeviceShaderCorePropertiesAMD* copy_src)
{
sType = copy_src->sType;
shaderEngineCount = copy_src->shaderEngineCount;
shaderArraysPerEngineCount = copy_src->shaderArraysPerEngineCount;
computeUnitsPerShaderArray = copy_src->computeUnitsPerShaderArray;
simdPerComputeUnit = copy_src->simdPerComputeUnit;
wavefrontsPerSimd = copy_src->wavefrontsPerSimd;
wavefrontSize = copy_src->wavefrontSize;
sgprsPerSimd = copy_src->sgprsPerSimd;
minSgprAllocation = copy_src->minSgprAllocation;
maxSgprAllocation = copy_src->maxSgprAllocation;
sgprAllocationGranularity = copy_src->sgprAllocationGranularity;
vgprsPerSimd = copy_src->vgprsPerSimd;
minVgprAllocation = copy_src->minVgprAllocation;
maxVgprAllocation = copy_src->maxVgprAllocation;
vgprAllocationGranularity = copy_src->vgprAllocationGranularity;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH265ProfileEXT::safe_VkVideoDecodeH265ProfileEXT(const VkVideoDecodeH265ProfileEXT* in_struct) :
sType(in_struct->sType),
stdProfileIdc(in_struct->stdProfileIdc)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoDecodeH265ProfileEXT::safe_VkVideoDecodeH265ProfileEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT),
pNext(nullptr)
{}
safe_VkVideoDecodeH265ProfileEXT::safe_VkVideoDecodeH265ProfileEXT(const safe_VkVideoDecodeH265ProfileEXT& copy_src)
{
sType = copy_src.sType;
stdProfileIdc = copy_src.stdProfileIdc;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoDecodeH265ProfileEXT& safe_VkVideoDecodeH265ProfileEXT::operator=(const safe_VkVideoDecodeH265ProfileEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stdProfileIdc = copy_src.stdProfileIdc;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoDecodeH265ProfileEXT::~safe_VkVideoDecodeH265ProfileEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH265ProfileEXT::initialize(const VkVideoDecodeH265ProfileEXT* in_struct)
{
sType = in_struct->sType;
stdProfileIdc = in_struct->stdProfileIdc;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoDecodeH265ProfileEXT::initialize(const safe_VkVideoDecodeH265ProfileEXT* copy_src)
{
sType = copy_src->sType;
stdProfileIdc = copy_src->stdProfileIdc;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH265CapabilitiesEXT::safe_VkVideoDecodeH265CapabilitiesEXT(const VkVideoDecodeH265CapabilitiesEXT* in_struct) :
sType(in_struct->sType),
maxLevel(in_struct->maxLevel),
stdExtensionVersion(in_struct->stdExtensionVersion)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVideoDecodeH265CapabilitiesEXT::safe_VkVideoDecodeH265CapabilitiesEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT),
pNext(nullptr)
{}
safe_VkVideoDecodeH265CapabilitiesEXT::safe_VkVideoDecodeH265CapabilitiesEXT(const safe_VkVideoDecodeH265CapabilitiesEXT& copy_src)
{
sType = copy_src.sType;
maxLevel = copy_src.maxLevel;
stdExtensionVersion = copy_src.stdExtensionVersion;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVideoDecodeH265CapabilitiesEXT& safe_VkVideoDecodeH265CapabilitiesEXT::operator=(const safe_VkVideoDecodeH265CapabilitiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxLevel = copy_src.maxLevel;
stdExtensionVersion = copy_src.stdExtensionVersion;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVideoDecodeH265CapabilitiesEXT::~safe_VkVideoDecodeH265CapabilitiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH265CapabilitiesEXT::initialize(const VkVideoDecodeH265CapabilitiesEXT* in_struct)
{
sType = in_struct->sType;
maxLevel = in_struct->maxLevel;
stdExtensionVersion = in_struct->stdExtensionVersion;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVideoDecodeH265CapabilitiesEXT::initialize(const safe_VkVideoDecodeH265CapabilitiesEXT* copy_src)
{
sType = copy_src->sType;
maxLevel = copy_src->maxLevel;
stdExtensionVersion = copy_src->stdExtensionVersion;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH265SessionCreateInfoEXT::safe_VkVideoDecodeH265SessionCreateInfoEXT(const VkVideoDecodeH265SessionCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
pStdExtensionVersion(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*in_struct->pStdExtensionVersion);
}
}
safe_VkVideoDecodeH265SessionCreateInfoEXT::safe_VkVideoDecodeH265SessionCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT),
pNext(nullptr),
pStdExtensionVersion(nullptr)
{}
safe_VkVideoDecodeH265SessionCreateInfoEXT::safe_VkVideoDecodeH265SessionCreateInfoEXT(const safe_VkVideoDecodeH265SessionCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src.pStdExtensionVersion);
}
}
safe_VkVideoDecodeH265SessionCreateInfoEXT& safe_VkVideoDecodeH265SessionCreateInfoEXT::operator=(const safe_VkVideoDecodeH265SessionCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdExtensionVersion)
delete pStdExtensionVersion;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src.pStdExtensionVersion);
}
return *this;
}
safe_VkVideoDecodeH265SessionCreateInfoEXT::~safe_VkVideoDecodeH265SessionCreateInfoEXT()
{
if (pStdExtensionVersion)
delete pStdExtensionVersion;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH265SessionCreateInfoEXT::initialize(const VkVideoDecodeH265SessionCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*in_struct->pStdExtensionVersion);
}
}
void safe_VkVideoDecodeH265SessionCreateInfoEXT::initialize(const safe_VkVideoDecodeH265SessionCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pStdExtensionVersion = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdExtensionVersion) {
pStdExtensionVersion = new VkExtensionProperties(*copy_src->pStdExtensionVersion);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH265SessionParametersAddInfoEXT::safe_VkVideoDecodeH265SessionParametersAddInfoEXT(const VkVideoDecodeH265SessionParametersAddInfoEXT* in_struct) :
sType(in_struct->sType),
spsStdCount(in_struct->spsStdCount),
pSpsStd(nullptr),
ppsStdCount(in_struct->ppsStdCount),
pPpsStd(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSpsStd) {
pSpsStd = new StdVideoH265SequenceParameterSet[in_struct->spsStdCount];
memcpy ((void *)pSpsStd, (void *)in_struct->pSpsStd, sizeof(StdVideoH265SequenceParameterSet)*in_struct->spsStdCount);
}
if (in_struct->pPpsStd) {
pPpsStd = new StdVideoH265PictureParameterSet[in_struct->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)in_struct->pPpsStd, sizeof(StdVideoH265PictureParameterSet)*in_struct->ppsStdCount);
}
}
safe_VkVideoDecodeH265SessionParametersAddInfoEXT::safe_VkVideoDecodeH265SessionParametersAddInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT),
pNext(nullptr),
pSpsStd(nullptr),
pPpsStd(nullptr)
{}
safe_VkVideoDecodeH265SessionParametersAddInfoEXT::safe_VkVideoDecodeH265SessionParametersAddInfoEXT(const safe_VkVideoDecodeH265SessionParametersAddInfoEXT& copy_src)
{
sType = copy_src.sType;
spsStdCount = copy_src.spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src.ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSpsStd) {
pSpsStd = new StdVideoH265SequenceParameterSet[copy_src.spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src.pSpsStd, sizeof(StdVideoH265SequenceParameterSet)*copy_src.spsStdCount);
}
if (copy_src.pPpsStd) {
pPpsStd = new StdVideoH265PictureParameterSet[copy_src.ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src.pPpsStd, sizeof(StdVideoH265PictureParameterSet)*copy_src.ppsStdCount);
}
}
safe_VkVideoDecodeH265SessionParametersAddInfoEXT& safe_VkVideoDecodeH265SessionParametersAddInfoEXT::operator=(const safe_VkVideoDecodeH265SessionParametersAddInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pSpsStd)
delete[] pSpsStd;
if (pPpsStd)
delete[] pPpsStd;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
spsStdCount = copy_src.spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src.ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pSpsStd) {
pSpsStd = new StdVideoH265SequenceParameterSet[copy_src.spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src.pSpsStd, sizeof(StdVideoH265SequenceParameterSet)*copy_src.spsStdCount);
}
if (copy_src.pPpsStd) {
pPpsStd = new StdVideoH265PictureParameterSet[copy_src.ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src.pPpsStd, sizeof(StdVideoH265PictureParameterSet)*copy_src.ppsStdCount);
}
return *this;
}
safe_VkVideoDecodeH265SessionParametersAddInfoEXT::~safe_VkVideoDecodeH265SessionParametersAddInfoEXT()
{
if (pSpsStd)
delete[] pSpsStd;
if (pPpsStd)
delete[] pPpsStd;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH265SessionParametersAddInfoEXT::initialize(const VkVideoDecodeH265SessionParametersAddInfoEXT* in_struct)
{
sType = in_struct->sType;
spsStdCount = in_struct->spsStdCount;
pSpsStd = nullptr;
ppsStdCount = in_struct->ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pSpsStd) {
pSpsStd = new StdVideoH265SequenceParameterSet[in_struct->spsStdCount];
memcpy ((void *)pSpsStd, (void *)in_struct->pSpsStd, sizeof(StdVideoH265SequenceParameterSet)*in_struct->spsStdCount);
}
if (in_struct->pPpsStd) {
pPpsStd = new StdVideoH265PictureParameterSet[in_struct->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)in_struct->pPpsStd, sizeof(StdVideoH265PictureParameterSet)*in_struct->ppsStdCount);
}
}
void safe_VkVideoDecodeH265SessionParametersAddInfoEXT::initialize(const safe_VkVideoDecodeH265SessionParametersAddInfoEXT* copy_src)
{
sType = copy_src->sType;
spsStdCount = copy_src->spsStdCount;
pSpsStd = nullptr;
ppsStdCount = copy_src->ppsStdCount;
pPpsStd = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pSpsStd) {
pSpsStd = new StdVideoH265SequenceParameterSet[copy_src->spsStdCount];
memcpy ((void *)pSpsStd, (void *)copy_src->pSpsStd, sizeof(StdVideoH265SequenceParameterSet)*copy_src->spsStdCount);
}
if (copy_src->pPpsStd) {
pPpsStd = new StdVideoH265PictureParameterSet[copy_src->ppsStdCount];
memcpy ((void *)pPpsStd, (void *)copy_src->pPpsStd, sizeof(StdVideoH265PictureParameterSet)*copy_src->ppsStdCount);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH265SessionParametersCreateInfoEXT::safe_VkVideoDecodeH265SessionParametersCreateInfoEXT(const VkVideoDecodeH265SessionParametersCreateInfoEXT* in_struct) :
sType(in_struct->sType),
maxSpsStdCount(in_struct->maxSpsStdCount),
maxPpsStdCount(in_struct->maxPpsStdCount),
pParametersAddInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoEXT(in_struct->pParametersAddInfo);
}
safe_VkVideoDecodeH265SessionParametersCreateInfoEXT::safe_VkVideoDecodeH265SessionParametersCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT),
pNext(nullptr),
pParametersAddInfo(nullptr)
{}
safe_VkVideoDecodeH265SessionParametersCreateInfoEXT::safe_VkVideoDecodeH265SessionParametersCreateInfoEXT(const safe_VkVideoDecodeH265SessionParametersCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
maxSpsStdCount = copy_src.maxSpsStdCount;
maxPpsStdCount = copy_src.maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo);
}
safe_VkVideoDecodeH265SessionParametersCreateInfoEXT& safe_VkVideoDecodeH265SessionParametersCreateInfoEXT::operator=(const safe_VkVideoDecodeH265SessionParametersCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pParametersAddInfo)
delete pParametersAddInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxSpsStdCount = copy_src.maxSpsStdCount;
maxPpsStdCount = copy_src.maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo);
return *this;
}
safe_VkVideoDecodeH265SessionParametersCreateInfoEXT::~safe_VkVideoDecodeH265SessionParametersCreateInfoEXT()
{
if (pParametersAddInfo)
delete pParametersAddInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH265SessionParametersCreateInfoEXT::initialize(const VkVideoDecodeH265SessionParametersCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
maxSpsStdCount = in_struct->maxSpsStdCount;
maxPpsStdCount = in_struct->maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoEXT(in_struct->pParametersAddInfo);
}
void safe_VkVideoDecodeH265SessionParametersCreateInfoEXT::initialize(const safe_VkVideoDecodeH265SessionParametersCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
maxSpsStdCount = copy_src->maxSpsStdCount;
maxPpsStdCount = copy_src->maxPpsStdCount;
pParametersAddInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pParametersAddInfo)
pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoEXT(*copy_src->pParametersAddInfo);
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH265PictureInfoEXT::safe_VkVideoDecodeH265PictureInfoEXT(const VkVideoDecodeH265PictureInfoEXT* in_struct) :
sType(in_struct->sType),
pStdPictureInfo(nullptr),
slicesCount(in_struct->slicesCount),
pSlicesDataOffsets(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*in_struct->pStdPictureInfo);
}
if (in_struct->pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[in_struct->slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)in_struct->pSlicesDataOffsets, sizeof(uint32_t)*in_struct->slicesCount);
}
}
safe_VkVideoDecodeH265PictureInfoEXT::safe_VkVideoDecodeH265PictureInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT),
pNext(nullptr),
pStdPictureInfo(nullptr),
pSlicesDataOffsets(nullptr)
{}
safe_VkVideoDecodeH265PictureInfoEXT::safe_VkVideoDecodeH265PictureInfoEXT(const safe_VkVideoDecodeH265PictureInfoEXT& copy_src)
{
sType = copy_src.sType;
pStdPictureInfo = nullptr;
slicesCount = copy_src.slicesCount;
pSlicesDataOffsets = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src.pStdPictureInfo);
}
if (copy_src.pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[copy_src.slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)copy_src.pSlicesDataOffsets, sizeof(uint32_t)*copy_src.slicesCount);
}
}
safe_VkVideoDecodeH265PictureInfoEXT& safe_VkVideoDecodeH265PictureInfoEXT::operator=(const safe_VkVideoDecodeH265PictureInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdPictureInfo)
delete pStdPictureInfo;
if (pSlicesDataOffsets)
delete[] pSlicesDataOffsets;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pStdPictureInfo = nullptr;
slicesCount = copy_src.slicesCount;
pSlicesDataOffsets = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src.pStdPictureInfo);
}
if (copy_src.pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[copy_src.slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)copy_src.pSlicesDataOffsets, sizeof(uint32_t)*copy_src.slicesCount);
}
return *this;
}
safe_VkVideoDecodeH265PictureInfoEXT::~safe_VkVideoDecodeH265PictureInfoEXT()
{
if (pStdPictureInfo)
delete pStdPictureInfo;
if (pSlicesDataOffsets)
delete[] pSlicesDataOffsets;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH265PictureInfoEXT::initialize(const VkVideoDecodeH265PictureInfoEXT* in_struct)
{
sType = in_struct->sType;
pStdPictureInfo = nullptr;
slicesCount = in_struct->slicesCount;
pSlicesDataOffsets = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*in_struct->pStdPictureInfo);
}
if (in_struct->pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[in_struct->slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)in_struct->pSlicesDataOffsets, sizeof(uint32_t)*in_struct->slicesCount);
}
}
void safe_VkVideoDecodeH265PictureInfoEXT::initialize(const safe_VkVideoDecodeH265PictureInfoEXT* copy_src)
{
sType = copy_src->sType;
pStdPictureInfo = nullptr;
slicesCount = copy_src->slicesCount;
pSlicesDataOffsets = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdPictureInfo) {
pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src->pStdPictureInfo);
}
if (copy_src->pSlicesDataOffsets) {
pSlicesDataOffsets = new uint32_t[copy_src->slicesCount];
memcpy ((void *)pSlicesDataOffsets, (void *)copy_src->pSlicesDataOffsets, sizeof(uint32_t)*copy_src->slicesCount);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkVideoDecodeH265DpbSlotInfoEXT::safe_VkVideoDecodeH265DpbSlotInfoEXT(const VkVideoDecodeH265DpbSlotInfoEXT* in_struct) :
sType(in_struct->sType),
pStdReferenceInfo(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*in_struct->pStdReferenceInfo);
}
}
safe_VkVideoDecodeH265DpbSlotInfoEXT::safe_VkVideoDecodeH265DpbSlotInfoEXT() :
sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT),
pNext(nullptr),
pStdReferenceInfo(nullptr)
{}
safe_VkVideoDecodeH265DpbSlotInfoEXT::safe_VkVideoDecodeH265DpbSlotInfoEXT(const safe_VkVideoDecodeH265DpbSlotInfoEXT& copy_src)
{
sType = copy_src.sType;
pStdReferenceInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo);
}
}
safe_VkVideoDecodeH265DpbSlotInfoEXT& safe_VkVideoDecodeH265DpbSlotInfoEXT::operator=(const safe_VkVideoDecodeH265DpbSlotInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pStdReferenceInfo)
delete pStdReferenceInfo;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pStdReferenceInfo = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo);
}
return *this;
}
safe_VkVideoDecodeH265DpbSlotInfoEXT::~safe_VkVideoDecodeH265DpbSlotInfoEXT()
{
if (pStdReferenceInfo)
delete pStdReferenceInfo;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVideoDecodeH265DpbSlotInfoEXT::initialize(const VkVideoDecodeH265DpbSlotInfoEXT* in_struct)
{
sType = in_struct->sType;
pStdReferenceInfo = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*in_struct->pStdReferenceInfo);
}
}
void safe_VkVideoDecodeH265DpbSlotInfoEXT::initialize(const safe_VkVideoDecodeH265DpbSlotInfoEXT* copy_src)
{
sType = copy_src->sType;
pStdReferenceInfo = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pStdReferenceInfo) {
pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src->pStdReferenceInfo);
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct) :
sType(in_struct->sType),
overallocationBehavior(in_struct->overallocationBehavior)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD() :
sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD),
pNext(nullptr)
{}
safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src)
{
sType = copy_src.sType;
overallocationBehavior = copy_src.overallocationBehavior;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceMemoryOverallocationCreateInfoAMD& safe_VkDeviceMemoryOverallocationCreateInfoAMD::operator=(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
overallocationBehavior = copy_src.overallocationBehavior;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceMemoryOverallocationCreateInfoAMD::~safe_VkDeviceMemoryOverallocationCreateInfoAMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceMemoryOverallocationCreateInfoAMD::initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct)
{
sType = in_struct->sType;
overallocationBehavior = in_struct->overallocationBehavior;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceMemoryOverallocationCreateInfoAMD::initialize(const safe_VkDeviceMemoryOverallocationCreateInfoAMD* copy_src)
{
sType = copy_src->sType;
overallocationBehavior = copy_src->overallocationBehavior;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct) :
sType(in_struct->sType),
maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src)
{
sType = copy_src.sType;
maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct)
{
sType = in_struct->sType;
maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* copy_src)
{
sType = copy_src->sType;
maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT* in_struct) :
sType(in_struct->sType),
vertexBindingDivisorCount(in_struct->vertexBindingDivisorCount),
pVertexBindingDivisors(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVertexBindingDivisors) {
pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[in_struct->vertexBindingDivisorCount];
memcpy ((void *)pVertexBindingDivisors, (void *)in_struct->pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*in_struct->vertexBindingDivisorCount);
}
}
safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::safe_VkPipelineVertexInputDivisorStateCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT),
pNext(nullptr),
pVertexBindingDivisors(nullptr)
{}
safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount;
pVertexBindingDivisors = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVertexBindingDivisors) {
pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[copy_src.vertexBindingDivisorCount];
memcpy ((void *)pVertexBindingDivisors, (void *)copy_src.pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*copy_src.vertexBindingDivisorCount);
}
}
safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::operator=(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pVertexBindingDivisors)
delete[] pVertexBindingDivisors;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount;
pVertexBindingDivisors = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVertexBindingDivisors) {
pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[copy_src.vertexBindingDivisorCount];
memcpy ((void *)pVertexBindingDivisors, (void *)copy_src.pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*copy_src.vertexBindingDivisorCount);
}
return *this;
}
safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::~safe_VkPipelineVertexInputDivisorStateCreateInfoEXT()
{
if (pVertexBindingDivisors)
delete[] pVertexBindingDivisors;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::initialize(const VkPipelineVertexInputDivisorStateCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount;
pVertexBindingDivisors = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVertexBindingDivisors) {
pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[in_struct->vertexBindingDivisorCount];
memcpy ((void *)pVertexBindingDivisors, (void *)in_struct->pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*in_struct->vertexBindingDivisorCount);
}
}
void safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
vertexBindingDivisorCount = copy_src->vertexBindingDivisorCount;
pVertexBindingDivisors = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pVertexBindingDivisors) {
pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[copy_src->vertexBindingDivisorCount];
memcpy ((void *)pVertexBindingDivisors, (void *)copy_src->pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*copy_src->vertexBindingDivisorCount);
}
}
safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* in_struct) :
sType(in_struct->sType),
vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor),
vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& copy_src)
{
sType = copy_src.sType;
vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::operator=(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* in_struct)
{
sType = in_struct->sType;
vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor;
vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* copy_src)
{
sType = copy_src->sType;
vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor;
vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_GGP
safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct) :
sType(in_struct->sType),
frameToken(in_struct->frameToken)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP() :
sType(VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP),
pNext(nullptr)
{}
safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP(const safe_VkPresentFrameTokenGGP& copy_src)
{
sType = copy_src.sType;
frameToken = copy_src.frameToken;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPresentFrameTokenGGP& safe_VkPresentFrameTokenGGP::operator=(const safe_VkPresentFrameTokenGGP& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
frameToken = copy_src.frameToken;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPresentFrameTokenGGP::~safe_VkPresentFrameTokenGGP()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPresentFrameTokenGGP::initialize(const VkPresentFrameTokenGGP* in_struct)
{
sType = in_struct->sType;
frameToken = in_struct->frameToken;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPresentFrameTokenGGP::initialize(const safe_VkPresentFrameTokenGGP* copy_src)
{
sType = copy_src->sType;
frameToken = copy_src->frameToken;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_GGP
safe_VkPipelineCreationFeedbackCreateInfoEXT::safe_VkPipelineCreationFeedbackCreateInfoEXT(const VkPipelineCreationFeedbackCreateInfoEXT* in_struct) :
sType(in_struct->sType),
pPipelineCreationFeedback(nullptr),
pipelineStageCreationFeedbackCount(in_struct->pipelineStageCreationFeedbackCount),
pPipelineStageCreationFeedbacks(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPipelineCreationFeedback) {
pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*in_struct->pPipelineCreationFeedback);
}
if (in_struct->pPipelineStageCreationFeedbacks) {
pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedbackEXT[in_struct->pipelineStageCreationFeedbackCount];
memcpy ((void *)pPipelineStageCreationFeedbacks, (void *)in_struct->pPipelineStageCreationFeedbacks, sizeof(VkPipelineCreationFeedbackEXT)*in_struct->pipelineStageCreationFeedbackCount);
}
}
safe_VkPipelineCreationFeedbackCreateInfoEXT::safe_VkPipelineCreationFeedbackCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT),
pNext(nullptr),
pPipelineCreationFeedback(nullptr),
pPipelineStageCreationFeedbacks(nullptr)
{}
safe_VkPipelineCreationFeedbackCreateInfoEXT::safe_VkPipelineCreationFeedbackCreateInfoEXT(const safe_VkPipelineCreationFeedbackCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
pPipelineCreationFeedback = nullptr;
pipelineStageCreationFeedbackCount = copy_src.pipelineStageCreationFeedbackCount;
pPipelineStageCreationFeedbacks = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPipelineCreationFeedback) {
pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*copy_src.pPipelineCreationFeedback);
}
if (copy_src.pPipelineStageCreationFeedbacks) {
pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedbackEXT[copy_src.pipelineStageCreationFeedbackCount];
memcpy ((void *)pPipelineStageCreationFeedbacks, (void *)copy_src.pPipelineStageCreationFeedbacks, sizeof(VkPipelineCreationFeedbackEXT)*copy_src.pipelineStageCreationFeedbackCount);
}
}
safe_VkPipelineCreationFeedbackCreateInfoEXT& safe_VkPipelineCreationFeedbackCreateInfoEXT::operator=(const safe_VkPipelineCreationFeedbackCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pPipelineCreationFeedback)
delete pPipelineCreationFeedback;
if (pPipelineStageCreationFeedbacks)
delete[] pPipelineStageCreationFeedbacks;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pPipelineCreationFeedback = nullptr;
pipelineStageCreationFeedbackCount = copy_src.pipelineStageCreationFeedbackCount;
pPipelineStageCreationFeedbacks = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pPipelineCreationFeedback) {
pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*copy_src.pPipelineCreationFeedback);
}
if (copy_src.pPipelineStageCreationFeedbacks) {
pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedbackEXT[copy_src.pipelineStageCreationFeedbackCount];
memcpy ((void *)pPipelineStageCreationFeedbacks, (void *)copy_src.pPipelineStageCreationFeedbacks, sizeof(VkPipelineCreationFeedbackEXT)*copy_src.pipelineStageCreationFeedbackCount);
}
return *this;
}
safe_VkPipelineCreationFeedbackCreateInfoEXT::~safe_VkPipelineCreationFeedbackCreateInfoEXT()
{
if (pPipelineCreationFeedback)
delete pPipelineCreationFeedback;
if (pPipelineStageCreationFeedbacks)
delete[] pPipelineStageCreationFeedbacks;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineCreationFeedbackCreateInfoEXT::initialize(const VkPipelineCreationFeedbackCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
pPipelineCreationFeedback = nullptr;
pipelineStageCreationFeedbackCount = in_struct->pipelineStageCreationFeedbackCount;
pPipelineStageCreationFeedbacks = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pPipelineCreationFeedback) {
pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*in_struct->pPipelineCreationFeedback);
}
if (in_struct->pPipelineStageCreationFeedbacks) {
pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedbackEXT[in_struct->pipelineStageCreationFeedbackCount];
memcpy ((void *)pPipelineStageCreationFeedbacks, (void *)in_struct->pPipelineStageCreationFeedbacks, sizeof(VkPipelineCreationFeedbackEXT)*in_struct->pipelineStageCreationFeedbackCount);
}
}
void safe_VkPipelineCreationFeedbackCreateInfoEXT::initialize(const safe_VkPipelineCreationFeedbackCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
pPipelineCreationFeedback = nullptr;
pipelineStageCreationFeedbackCount = copy_src->pipelineStageCreationFeedbackCount;
pPipelineStageCreationFeedbacks = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pPipelineCreationFeedback) {
pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*copy_src->pPipelineCreationFeedback);
}
if (copy_src->pPipelineStageCreationFeedbacks) {
pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedbackEXT[copy_src->pipelineStageCreationFeedbackCount];
memcpy ((void *)pPipelineStageCreationFeedbacks, (void *)copy_src->pPipelineStageCreationFeedbacks, sizeof(VkPipelineCreationFeedbackEXT)*copy_src->pipelineStageCreationFeedbackCount);
}
}
safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct) :
sType(in_struct->sType),
computeDerivativeGroupQuads(in_struct->computeDerivativeGroupQuads),
computeDerivativeGroupLinear(in_struct->computeDerivativeGroupLinear)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src)
{
sType = copy_src.sType;
computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct)
{
sType = in_struct->sType;
computeDerivativeGroupQuads = in_struct->computeDerivativeGroupQuads;
computeDerivativeGroupLinear = in_struct->computeDerivativeGroupLinear;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src)
{
sType = copy_src->sType;
computeDerivativeGroupQuads = copy_src->computeDerivativeGroupQuads;
computeDerivativeGroupLinear = copy_src->computeDerivativeGroupLinear;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct) :
sType(in_struct->sType),
taskShader(in_struct->taskShader),
meshShader(in_struct->meshShader)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src)
{
sType = copy_src.sType;
taskShader = copy_src.taskShader;
meshShader = copy_src.meshShader;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceMeshShaderFeaturesNV& safe_VkPhysicalDeviceMeshShaderFeaturesNV::operator=(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
taskShader = copy_src.taskShader;
meshShader = copy_src.meshShader;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceMeshShaderFeaturesNV::~safe_VkPhysicalDeviceMeshShaderFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMeshShaderFeaturesNV::initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct)
{
sType = in_struct->sType;
taskShader = in_struct->taskShader;
meshShader = in_struct->meshShader;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceMeshShaderFeaturesNV::initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesNV* copy_src)
{
sType = copy_src->sType;
taskShader = copy_src->taskShader;
meshShader = copy_src->meshShader;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct) :
sType(in_struct->sType),
maxDrawMeshTasksCount(in_struct->maxDrawMeshTasksCount),
maxTaskWorkGroupInvocations(in_struct->maxTaskWorkGroupInvocations),
maxTaskTotalMemorySize(in_struct->maxTaskTotalMemorySize),
maxTaskOutputCount(in_struct->maxTaskOutputCount),
maxMeshWorkGroupInvocations(in_struct->maxMeshWorkGroupInvocations),
maxMeshTotalMemorySize(in_struct->maxMeshTotalMemorySize),
maxMeshOutputVertices(in_struct->maxMeshOutputVertices),
maxMeshOutputPrimitives(in_struct->maxMeshOutputPrimitives),
maxMeshMultiviewViewCount(in_struct->maxMeshMultiviewViewCount),
meshOutputPerVertexGranularity(in_struct->meshOutputPerVertexGranularity),
meshOutputPerPrimitiveGranularity(in_struct->meshOutputPerPrimitiveGranularity)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 3; ++i) {
maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i];
}
for (uint32_t i = 0; i < 3; ++i) {
maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i];
}
}
safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src)
{
sType = copy_src.sType;
maxDrawMeshTasksCount = copy_src.maxDrawMeshTasksCount;
maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations;
maxTaskTotalMemorySize = copy_src.maxTaskTotalMemorySize;
maxTaskOutputCount = copy_src.maxTaskOutputCount;
maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations;
maxMeshTotalMemorySize = copy_src.maxMeshTotalMemorySize;
maxMeshOutputVertices = copy_src.maxMeshOutputVertices;
maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives;
maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount;
meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity;
meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 3; ++i) {
maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i];
}
for (uint32_t i = 0; i < 3; ++i) {
maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i];
}
}
safe_VkPhysicalDeviceMeshShaderPropertiesNV& safe_VkPhysicalDeviceMeshShaderPropertiesNV::operator=(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxDrawMeshTasksCount = copy_src.maxDrawMeshTasksCount;
maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations;
maxTaskTotalMemorySize = copy_src.maxTaskTotalMemorySize;
maxTaskOutputCount = copy_src.maxTaskOutputCount;
maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations;
maxMeshTotalMemorySize = copy_src.maxMeshTotalMemorySize;
maxMeshOutputVertices = copy_src.maxMeshOutputVertices;
maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives;
maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount;
meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity;
meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 3; ++i) {
maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i];
}
for (uint32_t i = 0; i < 3; ++i) {
maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i];
}
return *this;
}
safe_VkPhysicalDeviceMeshShaderPropertiesNV::~safe_VkPhysicalDeviceMeshShaderPropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct)
{
sType = in_struct->sType;
maxDrawMeshTasksCount = in_struct->maxDrawMeshTasksCount;
maxTaskWorkGroupInvocations = in_struct->maxTaskWorkGroupInvocations;
maxTaskTotalMemorySize = in_struct->maxTaskTotalMemorySize;
maxTaskOutputCount = in_struct->maxTaskOutputCount;
maxMeshWorkGroupInvocations = in_struct->maxMeshWorkGroupInvocations;
maxMeshTotalMemorySize = in_struct->maxMeshTotalMemorySize;
maxMeshOutputVertices = in_struct->maxMeshOutputVertices;
maxMeshOutputPrimitives = in_struct->maxMeshOutputPrimitives;
maxMeshMultiviewViewCount = in_struct->maxMeshMultiviewViewCount;
meshOutputPerVertexGranularity = in_struct->meshOutputPerVertexGranularity;
meshOutputPerPrimitiveGranularity = in_struct->meshOutputPerPrimitiveGranularity;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 3; ++i) {
maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i];
}
for (uint32_t i = 0; i < 3; ++i) {
maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i];
}
}
void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesNV* copy_src)
{
sType = copy_src->sType;
maxDrawMeshTasksCount = copy_src->maxDrawMeshTasksCount;
maxTaskWorkGroupInvocations = copy_src->maxTaskWorkGroupInvocations;
maxTaskTotalMemorySize = copy_src->maxTaskTotalMemorySize;
maxTaskOutputCount = copy_src->maxTaskOutputCount;
maxMeshWorkGroupInvocations = copy_src->maxMeshWorkGroupInvocations;
maxMeshTotalMemorySize = copy_src->maxMeshTotalMemorySize;
maxMeshOutputVertices = copy_src->maxMeshOutputVertices;
maxMeshOutputPrimitives = copy_src->maxMeshOutputPrimitives;
maxMeshMultiviewViewCount = copy_src->maxMeshMultiviewViewCount;
meshOutputPerVertexGranularity = copy_src->meshOutputPerVertexGranularity;
meshOutputPerPrimitiveGranularity = copy_src->meshOutputPerPrimitiveGranularity;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < 3; ++i) {
maxTaskWorkGroupSize[i] = copy_src->maxTaskWorkGroupSize[i];
}
for (uint32_t i = 0; i < 3; ++i) {
maxMeshWorkGroupSize[i] = copy_src->maxMeshWorkGroupSize[i];
}
}
safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* in_struct) :
sType(in_struct->sType),
fragmentShaderBarycentric(in_struct->fragmentShaderBarycentric)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& copy_src)
{
sType = copy_src.sType;
fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::operator=(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::initialize(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* in_struct)
{
sType = in_struct->sType;
fragmentShaderBarycentric = in_struct->fragmentShaderBarycentric;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* copy_src)
{
sType = copy_src->sType;
fragmentShaderBarycentric = copy_src->fragmentShaderBarycentric;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct) :
sType(in_struct->sType),
imageFootprint(in_struct->imageFootprint)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src)
{
sType = copy_src.sType;
imageFootprint = copy_src.imageFootprint;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::operator=(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
imageFootprint = copy_src.imageFootprint;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::~safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::initialize(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct)
{
sType = in_struct->sType;
imageFootprint = in_struct->imageFootprint;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::initialize(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV* copy_src)
{
sType = copy_src->sType;
imageFootprint = copy_src->imageFootprint;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
exclusiveScissorCount(in_struct->exclusiveScissorCount),
pExclusiveScissors(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pExclusiveScissors) {
pExclusiveScissors = new VkRect2D[in_struct->exclusiveScissorCount];
memcpy ((void *)pExclusiveScissors, (void *)in_struct->pExclusiveScissors, sizeof(VkRect2D)*in_struct->exclusiveScissorCount);
}
}
safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV),
pNext(nullptr),
pExclusiveScissors(nullptr)
{}
safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
exclusiveScissorCount = copy_src.exclusiveScissorCount;
pExclusiveScissors = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pExclusiveScissors) {
pExclusiveScissors = new VkRect2D[copy_src.exclusiveScissorCount];
memcpy ((void *)pExclusiveScissors, (void *)copy_src.pExclusiveScissors, sizeof(VkRect2D)*copy_src.exclusiveScissorCount);
}
}
safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::operator=(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pExclusiveScissors)
delete[] pExclusiveScissors;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
exclusiveScissorCount = copy_src.exclusiveScissorCount;
pExclusiveScissors = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pExclusiveScissors) {
pExclusiveScissors = new VkRect2D[copy_src.exclusiveScissorCount];
memcpy ((void *)pExclusiveScissors, (void *)copy_src.pExclusiveScissors, sizeof(VkRect2D)*copy_src.exclusiveScissorCount);
}
return *this;
}
safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::~safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV()
{
if (pExclusiveScissors)
delete[] pExclusiveScissors;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
exclusiveScissorCount = in_struct->exclusiveScissorCount;
pExclusiveScissors = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pExclusiveScissors) {
pExclusiveScissors = new VkRect2D[in_struct->exclusiveScissorCount];
memcpy ((void *)pExclusiveScissors, (void *)in_struct->pExclusiveScissors, sizeof(VkRect2D)*in_struct->exclusiveScissorCount);
}
}
void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
exclusiveScissorCount = copy_src->exclusiveScissorCount;
pExclusiveScissors = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pExclusiveScissors) {
pExclusiveScissors = new VkRect2D[copy_src->exclusiveScissorCount];
memcpy ((void *)pExclusiveScissors, (void *)copy_src->pExclusiveScissors, sizeof(VkRect2D)*copy_src->exclusiveScissorCount);
}
}
safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct) :
sType(in_struct->sType),
exclusiveScissor(in_struct->exclusiveScissor)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src)
{
sType = copy_src.sType;
exclusiveScissor = copy_src.exclusiveScissor;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::operator=(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
exclusiveScissor = copy_src.exclusiveScissor;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::~safe_VkPhysicalDeviceExclusiveScissorFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct)
{
sType = in_struct->sType;
exclusiveScissor = in_struct->exclusiveScissor;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::initialize(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV* copy_src)
{
sType = copy_src->sType;
exclusiveScissor = copy_src->exclusiveScissor;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV* in_struct) :
sType(in_struct->sType),
checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV() :
sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV(const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src)
{
sType = copy_src.sType;
checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkQueueFamilyCheckpointPropertiesNV& safe_VkQueueFamilyCheckpointPropertiesNV::operator=(const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkQueueFamilyCheckpointPropertiesNV::~safe_VkQueueFamilyCheckpointPropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkQueueFamilyCheckpointPropertiesNV::initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct)
{
sType = in_struct->sType;
checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkQueueFamilyCheckpointPropertiesNV::initialize(const safe_VkQueueFamilyCheckpointPropertiesNV* copy_src)
{
sType = copy_src->sType;
checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCheckpointDataNV::safe_VkCheckpointDataNV(const VkCheckpointDataNV* in_struct) :
sType(in_struct->sType),
stage(in_struct->stage),
pCheckpointMarker(in_struct->pCheckpointMarker)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCheckpointDataNV::safe_VkCheckpointDataNV() :
sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV),
pNext(nullptr),
pCheckpointMarker(nullptr)
{}
safe_VkCheckpointDataNV::safe_VkCheckpointDataNV(const safe_VkCheckpointDataNV& copy_src)
{
sType = copy_src.sType;
stage = copy_src.stage;
pCheckpointMarker = copy_src.pCheckpointMarker;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCheckpointDataNV& safe_VkCheckpointDataNV::operator=(const safe_VkCheckpointDataNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stage = copy_src.stage;
pCheckpointMarker = copy_src.pCheckpointMarker;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCheckpointDataNV::~safe_VkCheckpointDataNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCheckpointDataNV::initialize(const VkCheckpointDataNV* in_struct)
{
sType = in_struct->sType;
stage = in_struct->stage;
pCheckpointMarker = in_struct->pCheckpointMarker;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCheckpointDataNV::initialize(const safe_VkCheckpointDataNV* copy_src)
{
sType = copy_src->sType;
stage = copy_src->stage;
pCheckpointMarker = copy_src->pCheckpointMarker;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct) :
sType(in_struct->sType),
shaderIntegerFunctions2(in_struct->shaderIntegerFunctions2)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src)
{
sType = copy_src.sType;
shaderIntegerFunctions2 = copy_src.shaderIntegerFunctions2;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderIntegerFunctions2 = copy_src.shaderIntegerFunctions2;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct)
{
sType = in_struct->sType;
shaderIntegerFunctions2 = in_struct->shaderIntegerFunctions2;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* copy_src)
{
sType = copy_src->sType;
shaderIntegerFunctions2 = copy_src->shaderIntegerFunctions2;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct)
{
initialize(in_struct);
}
safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL() :
valueString(nullptr)
{}
safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const safe_VkPerformanceValueDataINTEL& copy_src)
{
value32 = copy_src.value32;
value64 = copy_src.value64;
valueFloat = copy_src.valueFloat;
valueBool = copy_src.valueBool;
valueString = SafeStringCopy(copy_src.valueString);
}
safe_VkPerformanceValueDataINTEL& safe_VkPerformanceValueDataINTEL::operator=(const safe_VkPerformanceValueDataINTEL& copy_src)
{
if (&copy_src == this) return *this;
if (valueString) delete [] valueString;
value32 = copy_src.value32;
value64 = copy_src.value64;
valueFloat = copy_src.valueFloat;
valueBool = copy_src.valueBool;
valueString = SafeStringCopy(copy_src.valueString);
return *this;
}
safe_VkPerformanceValueDataINTEL::~safe_VkPerformanceValueDataINTEL()
{
if (valueString) delete [] valueString;
}
void safe_VkPerformanceValueDataINTEL::initialize(const VkPerformanceValueDataINTEL* in_struct)
{
value32 = in_struct->value32;
value64 = in_struct->value64;
valueFloat = in_struct->valueFloat;
valueBool = in_struct->valueBool;
valueString = SafeStringCopy(in_struct->valueString);
}
void safe_VkPerformanceValueDataINTEL::initialize(const safe_VkPerformanceValueDataINTEL* copy_src)
{
value32 = copy_src->value32;
value64 = copy_src->value64;
valueFloat = copy_src->valueFloat;
valueBool = copy_src->valueBool;
valueString = SafeStringCopy(copy_src->valueString);
}
safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL* in_struct) :
sType(in_struct->sType),
pUserData(in_struct->pUserData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL() :
sType(VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL),
pNext(nullptr),
pUserData(nullptr)
{}
safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL(const safe_VkInitializePerformanceApiInfoINTEL& copy_src)
{
sType = copy_src.sType;
pUserData = copy_src.pUserData;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkInitializePerformanceApiInfoINTEL& safe_VkInitializePerformanceApiInfoINTEL::operator=(const safe_VkInitializePerformanceApiInfoINTEL& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pUserData = copy_src.pUserData;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkInitializePerformanceApiInfoINTEL::~safe_VkInitializePerformanceApiInfoINTEL()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkInitializePerformanceApiInfoINTEL::initialize(const VkInitializePerformanceApiInfoINTEL* in_struct)
{
sType = in_struct->sType;
pUserData = in_struct->pUserData;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkInitializePerformanceApiInfoINTEL::initialize(const safe_VkInitializePerformanceApiInfoINTEL* copy_src)
{
sType = copy_src->sType;
pUserData = copy_src->pUserData;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct) :
sType(in_struct->sType),
performanceCountersSampling(in_struct->performanceCountersSampling)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL() :
sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL),
pNext(nullptr)
{}
safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src)
{
sType = copy_src.sType;
performanceCountersSampling = copy_src.performanceCountersSampling;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::operator=(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
performanceCountersSampling = copy_src.performanceCountersSampling;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::~safe_VkQueryPoolPerformanceQueryCreateInfoINTEL()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::initialize(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct)
{
sType = in_struct->sType;
performanceCountersSampling = in_struct->performanceCountersSampling;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::initialize(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL* copy_src)
{
sType = copy_src->sType;
performanceCountersSampling = copy_src->performanceCountersSampling;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct) :
sType(in_struct->sType),
marker(in_struct->marker)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL() :
sType(VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL),
pNext(nullptr)
{}
safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL(const safe_VkPerformanceMarkerInfoINTEL& copy_src)
{
sType = copy_src.sType;
marker = copy_src.marker;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPerformanceMarkerInfoINTEL& safe_VkPerformanceMarkerInfoINTEL::operator=(const safe_VkPerformanceMarkerInfoINTEL& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
marker = copy_src.marker;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPerformanceMarkerInfoINTEL::~safe_VkPerformanceMarkerInfoINTEL()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPerformanceMarkerInfoINTEL::initialize(const VkPerformanceMarkerInfoINTEL* in_struct)
{
sType = in_struct->sType;
marker = in_struct->marker;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPerformanceMarkerInfoINTEL::initialize(const safe_VkPerformanceMarkerInfoINTEL* copy_src)
{
sType = copy_src->sType;
marker = copy_src->marker;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL* in_struct) :
sType(in_struct->sType),
marker(in_struct->marker)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL() :
sType(VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL),
pNext(nullptr)
{}
safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL(const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src)
{
sType = copy_src.sType;
marker = copy_src.marker;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPerformanceStreamMarkerInfoINTEL& safe_VkPerformanceStreamMarkerInfoINTEL::operator=(const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
marker = copy_src.marker;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPerformanceStreamMarkerInfoINTEL::~safe_VkPerformanceStreamMarkerInfoINTEL()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPerformanceStreamMarkerInfoINTEL::initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct)
{
sType = in_struct->sType;
marker = in_struct->marker;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPerformanceStreamMarkerInfoINTEL::initialize(const safe_VkPerformanceStreamMarkerInfoINTEL* copy_src)
{
sType = copy_src->sType;
marker = copy_src->marker;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct) :
sType(in_struct->sType),
type(in_struct->type),
enable(in_struct->enable),
parameter(in_struct->parameter)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL() :
sType(VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL),
pNext(nullptr)
{}
safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL(const safe_VkPerformanceOverrideInfoINTEL& copy_src)
{
sType = copy_src.sType;
type = copy_src.type;
enable = copy_src.enable;
parameter = copy_src.parameter;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPerformanceOverrideInfoINTEL& safe_VkPerformanceOverrideInfoINTEL::operator=(const safe_VkPerformanceOverrideInfoINTEL& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
type = copy_src.type;
enable = copy_src.enable;
parameter = copy_src.parameter;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPerformanceOverrideInfoINTEL::~safe_VkPerformanceOverrideInfoINTEL()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPerformanceOverrideInfoINTEL::initialize(const VkPerformanceOverrideInfoINTEL* in_struct)
{
sType = in_struct->sType;
type = in_struct->type;
enable = in_struct->enable;
parameter = in_struct->parameter;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPerformanceOverrideInfoINTEL::initialize(const safe_VkPerformanceOverrideInfoINTEL* copy_src)
{
sType = copy_src->sType;
type = copy_src->type;
enable = copy_src->enable;
parameter = copy_src->parameter;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct) :
sType(in_struct->sType),
type(in_struct->type)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL() :
sType(VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL),
pNext(nullptr)
{}
safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL(const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src)
{
sType = copy_src.sType;
type = copy_src.type;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPerformanceConfigurationAcquireInfoINTEL& safe_VkPerformanceConfigurationAcquireInfoINTEL::operator=(const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
type = copy_src.type;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPerformanceConfigurationAcquireInfoINTEL::~safe_VkPerformanceConfigurationAcquireInfoINTEL()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPerformanceConfigurationAcquireInfoINTEL::initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct)
{
sType = in_struct->sType;
type = in_struct->type;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPerformanceConfigurationAcquireInfoINTEL::initialize(const safe_VkPerformanceConfigurationAcquireInfoINTEL* copy_src)
{
sType = copy_src->sType;
type = copy_src->type;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct) :
sType(in_struct->sType),
pciDomain(in_struct->pciDomain),
pciBus(in_struct->pciBus),
pciDevice(in_struct->pciDevice),
pciFunction(in_struct->pciFunction)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src)
{
sType = copy_src.sType;
pciDomain = copy_src.pciDomain;
pciBus = copy_src.pciBus;
pciDevice = copy_src.pciDevice;
pciFunction = copy_src.pciFunction;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::operator=(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pciDomain = copy_src.pciDomain;
pciBus = copy_src.pciBus;
pciDevice = copy_src.pciDevice;
pciFunction = copy_src.pciFunction;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::~safe_VkPhysicalDevicePCIBusInfoPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct)
{
sType = in_struct->sType;
pciDomain = in_struct->pciDomain;
pciBus = in_struct->pciBus;
pciDevice = in_struct->pciDevice;
pciFunction = in_struct->pciFunction;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::initialize(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT* copy_src)
{
sType = copy_src->sType;
pciDomain = copy_src->pciDomain;
pciBus = copy_src->pciBus;
pciDevice = copy_src->pciDevice;
pciFunction = copy_src->pciFunction;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct) :
sType(in_struct->sType),
localDimmingSupport(in_struct->localDimmingSupport)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD() :
sType(VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD),
pNext(nullptr)
{}
safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src)
{
sType = copy_src.sType;
localDimmingSupport = copy_src.localDimmingSupport;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::operator=(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
localDimmingSupport = copy_src.localDimmingSupport;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::~safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct)
{
sType = in_struct->sType;
localDimmingSupport = in_struct->localDimmingSupport;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD* copy_src)
{
sType = copy_src->sType;
localDimmingSupport = copy_src->localDimmingSupport;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct) :
sType(in_struct->sType),
localDimmingEnable(in_struct->localDimmingEnable)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD() :
sType(VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD),
pNext(nullptr)
{}
safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src)
{
sType = copy_src.sType;
localDimmingEnable = copy_src.localDimmingEnable;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::operator=(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
localDimmingEnable = copy_src.localDimmingEnable;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::~safe_VkSwapchainDisplayNativeHdrCreateInfoAMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct)
{
sType = in_struct->sType;
localDimmingEnable = in_struct->localDimmingEnable;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::initialize(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD* copy_src)
{
sType = copy_src->sType;
localDimmingEnable = copy_src->localDimmingEnable;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_FUCHSIA
safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
imagePipeHandle(in_struct->imagePipeHandle)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA() :
sType(VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA),
pNext(nullptr)
{}
safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
imagePipeHandle = copy_src.imagePipeHandle;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImagePipeSurfaceCreateInfoFUCHSIA& safe_VkImagePipeSurfaceCreateInfoFUCHSIA::operator=(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
imagePipeHandle = copy_src.imagePipeHandle;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImagePipeSurfaceCreateInfoFUCHSIA::~safe_VkImagePipeSurfaceCreateInfoFUCHSIA()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
imagePipeHandle = in_struct->imagePipeHandle;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
imagePipeHandle = copy_src->imagePipeHandle;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_FUCHSIA
safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct) :
sType(in_struct->sType),
fragmentDensityMap(in_struct->fragmentDensityMap),
fragmentDensityMapDynamic(in_struct->fragmentDensityMapDynamic),
fragmentDensityMapNonSubsampledImages(in_struct->fragmentDensityMapNonSubsampledImages)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src)
{
sType = copy_src.sType;
fragmentDensityMap = copy_src.fragmentDensityMap;
fragmentDensityMapDynamic = copy_src.fragmentDensityMapDynamic;
fragmentDensityMapNonSubsampledImages = copy_src.fragmentDensityMapNonSubsampledImages;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::operator=(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fragmentDensityMap = copy_src.fragmentDensityMap;
fragmentDensityMapDynamic = copy_src.fragmentDensityMapDynamic;
fragmentDensityMapNonSubsampledImages = copy_src.fragmentDensityMapNonSubsampledImages;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::~safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct)
{
sType = in_struct->sType;
fragmentDensityMap = in_struct->fragmentDensityMap;
fragmentDensityMapDynamic = in_struct->fragmentDensityMapDynamic;
fragmentDensityMapNonSubsampledImages = in_struct->fragmentDensityMapNonSubsampledImages;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::initialize(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* copy_src)
{
sType = copy_src->sType;
fragmentDensityMap = copy_src->fragmentDensityMap;
fragmentDensityMapDynamic = copy_src->fragmentDensityMapDynamic;
fragmentDensityMapNonSubsampledImages = copy_src->fragmentDensityMapNonSubsampledImages;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct) :
sType(in_struct->sType),
minFragmentDensityTexelSize(in_struct->minFragmentDensityTexelSize),
maxFragmentDensityTexelSize(in_struct->maxFragmentDensityTexelSize),
fragmentDensityInvocations(in_struct->fragmentDensityInvocations)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src)
{
sType = copy_src.sType;
minFragmentDensityTexelSize = copy_src.minFragmentDensityTexelSize;
maxFragmentDensityTexelSize = copy_src.maxFragmentDensityTexelSize;
fragmentDensityInvocations = copy_src.fragmentDensityInvocations;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::operator=(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
minFragmentDensityTexelSize = copy_src.minFragmentDensityTexelSize;
maxFragmentDensityTexelSize = copy_src.maxFragmentDensityTexelSize;
fragmentDensityInvocations = copy_src.fragmentDensityInvocations;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::~safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::initialize(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct)
{
sType = in_struct->sType;
minFragmentDensityTexelSize = in_struct->minFragmentDensityTexelSize;
maxFragmentDensityTexelSize = in_struct->maxFragmentDensityTexelSize;
fragmentDensityInvocations = in_struct->fragmentDensityInvocations;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::initialize(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* copy_src)
{
sType = copy_src->sType;
minFragmentDensityTexelSize = copy_src->minFragmentDensityTexelSize;
maxFragmentDensityTexelSize = copy_src->maxFragmentDensityTexelSize;
fragmentDensityInvocations = copy_src->fragmentDensityInvocations;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct) :
sType(in_struct->sType),
fragmentDensityMapAttachment(in_struct->fragmentDensityMapAttachment)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
fragmentDensityMapAttachment = copy_src.fragmentDensityMapAttachment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkRenderPassFragmentDensityMapCreateInfoEXT& safe_VkRenderPassFragmentDensityMapCreateInfoEXT::operator=(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fragmentDensityMapAttachment = copy_src.fragmentDensityMapAttachment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkRenderPassFragmentDensityMapCreateInfoEXT::~safe_VkRenderPassFragmentDensityMapCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
fragmentDensityMapAttachment = in_struct->fragmentDensityMapAttachment;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
fragmentDensityMapAttachment = copy_src->fragmentDensityMapAttachment;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct) :
sType(in_struct->sType),
subgroupSizeControl(in_struct->subgroupSizeControl),
computeFullSubgroups(in_struct->computeFullSubgroups)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& copy_src)
{
sType = copy_src.sType;
subgroupSizeControl = copy_src.subgroupSizeControl;
computeFullSubgroups = copy_src.computeFullSubgroups;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::operator=(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
subgroupSizeControl = copy_src.subgroupSizeControl;
computeFullSubgroups = copy_src.computeFullSubgroups;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::~safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::initialize(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct)
{
sType = in_struct->sType;
subgroupSizeControl = in_struct->subgroupSizeControl;
computeFullSubgroups = in_struct->computeFullSubgroups;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* copy_src)
{
sType = copy_src->sType;
subgroupSizeControl = copy_src->subgroupSizeControl;
computeFullSubgroups = copy_src->computeFullSubgroups;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct) :
sType(in_struct->sType),
minSubgroupSize(in_struct->minSubgroupSize),
maxSubgroupSize(in_struct->maxSubgroupSize),
maxComputeWorkgroupSubgroups(in_struct->maxComputeWorkgroupSubgroups),
requiredSubgroupSizeStages(in_struct->requiredSubgroupSizeStages)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& copy_src)
{
sType = copy_src.sType;
minSubgroupSize = copy_src.minSubgroupSize;
maxSubgroupSize = copy_src.maxSubgroupSize;
maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups;
requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::operator=(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
minSubgroupSize = copy_src.minSubgroupSize;
maxSubgroupSize = copy_src.maxSubgroupSize;
maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups;
requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::~safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::initialize(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct)
{
sType = in_struct->sType;
minSubgroupSize = in_struct->minSubgroupSize;
maxSubgroupSize = in_struct->maxSubgroupSize;
maxComputeWorkgroupSubgroups = in_struct->maxComputeWorkgroupSubgroups;
requiredSubgroupSizeStages = in_struct->requiredSubgroupSizeStages;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::initialize(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* copy_src)
{
sType = copy_src->sType;
minSubgroupSize = copy_src->minSubgroupSize;
maxSubgroupSize = copy_src->maxSubgroupSize;
maxComputeWorkgroupSubgroups = copy_src->maxComputeWorkgroupSubgroups;
requiredSubgroupSizeStages = copy_src->requiredSubgroupSizeStages;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct) :
sType(in_struct->sType),
requiredSubgroupSize(in_struct->requiredSubgroupSize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
requiredSubgroupSize = copy_src.requiredSubgroupSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::operator=(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
requiredSubgroupSize = copy_src.requiredSubgroupSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::initialize(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
requiredSubgroupSize = in_struct->requiredSubgroupSize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::initialize(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
requiredSubgroupSize = copy_src->requiredSubgroupSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct) :
sType(in_struct->sType),
shaderCoreFeatures(in_struct->shaderCoreFeatures),
activeComputeUnitCount(in_struct->activeComputeUnitCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src)
{
sType = copy_src.sType;
shaderCoreFeatures = copy_src.shaderCoreFeatures;
activeComputeUnitCount = copy_src.activeComputeUnitCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderCoreProperties2AMD& safe_VkPhysicalDeviceShaderCoreProperties2AMD::operator=(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderCoreFeatures = copy_src.shaderCoreFeatures;
activeComputeUnitCount = copy_src.activeComputeUnitCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderCoreProperties2AMD::~safe_VkPhysicalDeviceShaderCoreProperties2AMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderCoreProperties2AMD::initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct)
{
sType = in_struct->sType;
shaderCoreFeatures = in_struct->shaderCoreFeatures;
activeComputeUnitCount = in_struct->activeComputeUnitCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderCoreProperties2AMD::initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* copy_src)
{
sType = copy_src->sType;
shaderCoreFeatures = copy_src->shaderCoreFeatures;
activeComputeUnitCount = copy_src->activeComputeUnitCount;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct) :
sType(in_struct->sType),
deviceCoherentMemory(in_struct->deviceCoherentMemory)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD),
pNext(nullptr)
{}
safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src)
{
sType = copy_src.sType;
deviceCoherentMemory = copy_src.deviceCoherentMemory;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::operator=(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceCoherentMemory = copy_src.deviceCoherentMemory;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct)
{
sType = in_struct->sType;
deviceCoherentMemory = in_struct->deviceCoherentMemory;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* copy_src)
{
sType = copy_src->sType;
deviceCoherentMemory = copy_src->deviceCoherentMemory;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct) :
sType(in_struct->sType),
shaderImageInt64Atomics(in_struct->shaderImageInt64Atomics),
sparseImageInt64Atomics(in_struct->sparseImageInt64Atomics)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src)
{
sType = copy_src.sType;
shaderImageInt64Atomics = copy_src.shaderImageInt64Atomics;
sparseImageInt64Atomics = copy_src.sparseImageInt64Atomics;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::operator=(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderImageInt64Atomics = copy_src.shaderImageInt64Atomics;
sparseImageInt64Atomics = copy_src.sparseImageInt64Atomics;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::~safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::initialize(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct)
{
sType = in_struct->sType;
shaderImageInt64Atomics = in_struct->shaderImageInt64Atomics;
sparseImageInt64Atomics = in_struct->sparseImageInt64Atomics;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* copy_src)
{
sType = copy_src->sType;
shaderImageInt64Atomics = copy_src->shaderImageInt64Atomics;
sparseImageInt64Atomics = copy_src->sparseImageInt64Atomics;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct) :
sType(in_struct->sType)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapBudget[i] = in_struct->heapBudget[i];
}
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapUsage[i] = in_struct->heapUsage[i];
}
}
safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src)
{
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapBudget[i] = copy_src.heapBudget[i];
}
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapUsage[i] = copy_src.heapUsage[i];
}
}
safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::operator=(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapBudget[i] = copy_src.heapBudget[i];
}
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapUsage[i] = copy_src.heapUsage[i];
}
return *this;
}
safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::~safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct)
{
sType = in_struct->sType;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapBudget[i] = in_struct->heapBudget[i];
}
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapUsage[i] = in_struct->heapUsage[i];
}
}
void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT* copy_src)
{
sType = copy_src->sType;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapBudget[i] = copy_src->heapBudget[i];
}
for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
heapUsage[i] = copy_src->heapUsage[i];
}
}
safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct) :
sType(in_struct->sType),
memoryPriority(in_struct->memoryPriority)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src)
{
sType = copy_src.sType;
memoryPriority = copy_src.memoryPriority;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::operator=(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryPriority = copy_src.memoryPriority;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::~safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct)
{
sType = in_struct->sType;
memoryPriority = in_struct->memoryPriority;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT* copy_src)
{
sType = copy_src->sType;
memoryPriority = copy_src->memoryPriority;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct) :
sType(in_struct->sType),
priority(in_struct->priority)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT() :
sType(VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src)
{
sType = copy_src.sType;
priority = copy_src.priority;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryPriorityAllocateInfoEXT& safe_VkMemoryPriorityAllocateInfoEXT::operator=(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
priority = copy_src.priority;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryPriorityAllocateInfoEXT::~safe_VkMemoryPriorityAllocateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryPriorityAllocateInfoEXT::initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct)
{
sType = in_struct->sType;
priority = in_struct->priority;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryPriorityAllocateInfoEXT::initialize(const safe_VkMemoryPriorityAllocateInfoEXT* copy_src)
{
sType = copy_src->sType;
priority = copy_src->priority;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct) :
sType(in_struct->sType),
dedicatedAllocationImageAliasing(in_struct->dedicatedAllocationImageAliasing)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src)
{
sType = copy_src.sType;
dedicatedAllocationImageAliasing = copy_src.dedicatedAllocationImageAliasing;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
dedicatedAllocationImageAliasing = copy_src.dedicatedAllocationImageAliasing;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::~safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct)
{
sType = in_struct->sType;
dedicatedAllocationImageAliasing = in_struct->dedicatedAllocationImageAliasing;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* copy_src)
{
sType = copy_src->sType;
dedicatedAllocationImageAliasing = copy_src->dedicatedAllocationImageAliasing;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct) :
sType(in_struct->sType),
bufferDeviceAddress(in_struct->bufferDeviceAddress),
bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay),
bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src)
{
sType = copy_src.sType;
bufferDeviceAddress = copy_src.bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
bufferDeviceAddress = copy_src.bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::~safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct)
{
sType = in_struct->sType;
bufferDeviceAddress = in_struct->bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* copy_src)
{
sType = copy_src->sType;
bufferDeviceAddress = copy_src->bufferDeviceAddress;
bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay;
bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT* in_struct) :
sType(in_struct->sType),
deviceAddress(in_struct->deviceAddress)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT(const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
deviceAddress = copy_src.deviceAddress;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkBufferDeviceAddressCreateInfoEXT& safe_VkBufferDeviceAddressCreateInfoEXT::operator=(const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceAddress = copy_src.deviceAddress;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkBufferDeviceAddressCreateInfoEXT::~safe_VkBufferDeviceAddressCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkBufferDeviceAddressCreateInfoEXT::initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
deviceAddress = in_struct->deviceAddress;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkBufferDeviceAddressCreateInfoEXT::initialize(const safe_VkBufferDeviceAddressCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
deviceAddress = copy_src->deviceAddress;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceToolPropertiesEXT::safe_VkPhysicalDeviceToolPropertiesEXT(const VkPhysicalDeviceToolPropertiesEXT* in_struct) :
sType(in_struct->sType),
purposes(in_struct->purposes)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
version[i] = in_struct->version[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
layer[i] = in_struct->layer[i];
}
}
safe_VkPhysicalDeviceToolPropertiesEXT::safe_VkPhysicalDeviceToolPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceToolPropertiesEXT::safe_VkPhysicalDeviceToolPropertiesEXT(const safe_VkPhysicalDeviceToolPropertiesEXT& copy_src)
{
sType = copy_src.sType;
purposes = copy_src.purposes;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
version[i] = copy_src.version[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
layer[i] = copy_src.layer[i];
}
}
safe_VkPhysicalDeviceToolPropertiesEXT& safe_VkPhysicalDeviceToolPropertiesEXT::operator=(const safe_VkPhysicalDeviceToolPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
purposes = copy_src.purposes;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
name[i] = copy_src.name[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
version[i] = copy_src.version[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src.description[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
layer[i] = copy_src.layer[i];
}
return *this;
}
safe_VkPhysicalDeviceToolPropertiesEXT::~safe_VkPhysicalDeviceToolPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceToolPropertiesEXT::initialize(const VkPhysicalDeviceToolPropertiesEXT* in_struct)
{
sType = in_struct->sType;
purposes = in_struct->purposes;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
name[i] = in_struct->name[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
version[i] = in_struct->version[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = in_struct->description[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
layer[i] = in_struct->layer[i];
}
}
void safe_VkPhysicalDeviceToolPropertiesEXT::initialize(const safe_VkPhysicalDeviceToolPropertiesEXT* copy_src)
{
sType = copy_src->sType;
purposes = copy_src->purposes;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
name[i] = copy_src->name[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
version[i] = copy_src->version[i];
}
for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
description[i] = copy_src->description[i];
}
for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
layer[i] = copy_src->layer[i];
}
}
safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct) :
sType(in_struct->sType),
enabledValidationFeatureCount(in_struct->enabledValidationFeatureCount),
pEnabledValidationFeatures(nullptr),
disabledValidationFeatureCount(in_struct->disabledValidationFeatureCount),
pDisabledValidationFeatures(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pEnabledValidationFeatures) {
pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[in_struct->enabledValidationFeatureCount];
memcpy ((void *)pEnabledValidationFeatures, (void *)in_struct->pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*in_struct->enabledValidationFeatureCount);
}
if (in_struct->pDisabledValidationFeatures) {
pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[in_struct->disabledValidationFeatureCount];
memcpy ((void *)pDisabledValidationFeatures, (void *)in_struct->pDisabledValidationFeatures, sizeof(VkValidationFeatureDisableEXT)*in_struct->disabledValidationFeatureCount);
}
}
safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT),
pNext(nullptr),
pEnabledValidationFeatures(nullptr),
pDisabledValidationFeatures(nullptr)
{}
safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const safe_VkValidationFeaturesEXT& copy_src)
{
sType = copy_src.sType;
enabledValidationFeatureCount = copy_src.enabledValidationFeatureCount;
pEnabledValidationFeatures = nullptr;
disabledValidationFeatureCount = copy_src.disabledValidationFeatureCount;
pDisabledValidationFeatures = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pEnabledValidationFeatures) {
pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src.enabledValidationFeatureCount];
memcpy ((void *)pEnabledValidationFeatures, (void *)copy_src.pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*copy_src.enabledValidationFeatureCount);
}
if (copy_src.pDisabledValidationFeatures) {
pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src.disabledValidationFeatureCount];
memcpy ((void *)pDisabledValidationFeatures, (void *)copy_src.pDisabledValidationFeatures, sizeof(VkValidationFeatureDisableEXT)*copy_src.disabledValidationFeatureCount);
}
}
safe_VkValidationFeaturesEXT& safe_VkValidationFeaturesEXT::operator=(const safe_VkValidationFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pEnabledValidationFeatures)
delete[] pEnabledValidationFeatures;
if (pDisabledValidationFeatures)
delete[] pDisabledValidationFeatures;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
enabledValidationFeatureCount = copy_src.enabledValidationFeatureCount;
pEnabledValidationFeatures = nullptr;
disabledValidationFeatureCount = copy_src.disabledValidationFeatureCount;
pDisabledValidationFeatures = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pEnabledValidationFeatures) {
pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src.enabledValidationFeatureCount];
memcpy ((void *)pEnabledValidationFeatures, (void *)copy_src.pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*copy_src.enabledValidationFeatureCount);
}
if (copy_src.pDisabledValidationFeatures) {
pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src.disabledValidationFeatureCount];
memcpy ((void *)pDisabledValidationFeatures, (void *)copy_src.pDisabledValidationFeatures, sizeof(VkValidationFeatureDisableEXT)*copy_src.disabledValidationFeatureCount);
}
return *this;
}
safe_VkValidationFeaturesEXT::~safe_VkValidationFeaturesEXT()
{
if (pEnabledValidationFeatures)
delete[] pEnabledValidationFeatures;
if (pDisabledValidationFeatures)
delete[] pDisabledValidationFeatures;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkValidationFeaturesEXT::initialize(const VkValidationFeaturesEXT* in_struct)
{
sType = in_struct->sType;
enabledValidationFeatureCount = in_struct->enabledValidationFeatureCount;
pEnabledValidationFeatures = nullptr;
disabledValidationFeatureCount = in_struct->disabledValidationFeatureCount;
pDisabledValidationFeatures = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pEnabledValidationFeatures) {
pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[in_struct->enabledValidationFeatureCount];
memcpy ((void *)pEnabledValidationFeatures, (void *)in_struct->pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*in_struct->enabledValidationFeatureCount);
}
if (in_struct->pDisabledValidationFeatures) {
pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[in_struct->disabledValidationFeatureCount];
memcpy ((void *)pDisabledValidationFeatures, (void *)in_struct->pDisabledValidationFeatures, sizeof(VkValidationFeatureDisableEXT)*in_struct->disabledValidationFeatureCount);
}
}
void safe_VkValidationFeaturesEXT::initialize(const safe_VkValidationFeaturesEXT* copy_src)
{
sType = copy_src->sType;
enabledValidationFeatureCount = copy_src->enabledValidationFeatureCount;
pEnabledValidationFeatures = nullptr;
disabledValidationFeatureCount = copy_src->disabledValidationFeatureCount;
pDisabledValidationFeatures = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pEnabledValidationFeatures) {
pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src->enabledValidationFeatureCount];
memcpy ((void *)pEnabledValidationFeatures, (void *)copy_src->pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*copy_src->enabledValidationFeatureCount);
}
if (copy_src->pDisabledValidationFeatures) {
pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src->disabledValidationFeatureCount];
memcpy ((void *)pDisabledValidationFeatures, (void *)copy_src->pDisabledValidationFeatures, sizeof(VkValidationFeatureDisableEXT)*copy_src->disabledValidationFeatureCount);
}
}
safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* in_struct) :
sType(in_struct->sType),
MSize(in_struct->MSize),
NSize(in_struct->NSize),
KSize(in_struct->KSize),
AType(in_struct->AType),
BType(in_struct->BType),
CType(in_struct->CType),
DType(in_struct->DType),
scope(in_struct->scope)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV() :
sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const safe_VkCooperativeMatrixPropertiesNV& copy_src)
{
sType = copy_src.sType;
MSize = copy_src.MSize;
NSize = copy_src.NSize;
KSize = copy_src.KSize;
AType = copy_src.AType;
BType = copy_src.BType;
CType = copy_src.CType;
DType = copy_src.DType;
scope = copy_src.scope;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCooperativeMatrixPropertiesNV& safe_VkCooperativeMatrixPropertiesNV::operator=(const safe_VkCooperativeMatrixPropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
MSize = copy_src.MSize;
NSize = copy_src.NSize;
KSize = copy_src.KSize;
AType = copy_src.AType;
BType = copy_src.BType;
CType = copy_src.CType;
DType = copy_src.DType;
scope = copy_src.scope;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCooperativeMatrixPropertiesNV::~safe_VkCooperativeMatrixPropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCooperativeMatrixPropertiesNV::initialize(const VkCooperativeMatrixPropertiesNV* in_struct)
{
sType = in_struct->sType;
MSize = in_struct->MSize;
NSize = in_struct->NSize;
KSize = in_struct->KSize;
AType = in_struct->AType;
BType = in_struct->BType;
CType = in_struct->CType;
DType = in_struct->DType;
scope = in_struct->scope;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCooperativeMatrixPropertiesNV::initialize(const safe_VkCooperativeMatrixPropertiesNV* copy_src)
{
sType = copy_src->sType;
MSize = copy_src->MSize;
NSize = copy_src->NSize;
KSize = copy_src->KSize;
AType = copy_src->AType;
BType = copy_src->BType;
CType = copy_src->CType;
DType = copy_src->DType;
scope = copy_src->scope;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct) :
sType(in_struct->sType),
cooperativeMatrix(in_struct->cooperativeMatrix),
cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src)
{
sType = copy_src.sType;
cooperativeMatrix = copy_src.cooperativeMatrix;
cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
cooperativeMatrix = copy_src.cooperativeMatrix;
cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct)
{
sType = in_struct->sType;
cooperativeMatrix = in_struct->cooperativeMatrix;
cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV* copy_src)
{
sType = copy_src->sType;
cooperativeMatrix = copy_src->cooperativeMatrix;
cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct) :
sType(in_struct->sType),
cooperativeMatrixSupportedStages(in_struct->cooperativeMatrixSupportedStages)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src)
{
sType = copy_src.sType;
cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::operator=(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct)
{
sType = in_struct->sType;
cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV* copy_src)
{
sType = copy_src->sType;
cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct) :
sType(in_struct->sType),
coverageReductionMode(in_struct->coverageReductionMode)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src)
{
sType = copy_src.sType;
coverageReductionMode = copy_src.coverageReductionMode;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::operator=(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
coverageReductionMode = copy_src.coverageReductionMode;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::~safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::initialize(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct)
{
sType = in_struct->sType;
coverageReductionMode = in_struct->coverageReductionMode;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::initialize(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV* copy_src)
{
sType = copy_src->sType;
coverageReductionMode = copy_src->coverageReductionMode;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
coverageReductionMode(in_struct->coverageReductionMode)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV(const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
coverageReductionMode = copy_src.coverageReductionMode;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineCoverageReductionStateCreateInfoNV& safe_VkPipelineCoverageReductionStateCreateInfoNV::operator=(const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
coverageReductionMode = copy_src.coverageReductionMode;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineCoverageReductionStateCreateInfoNV::~safe_VkPipelineCoverageReductionStateCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineCoverageReductionStateCreateInfoNV::initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
coverageReductionMode = in_struct->coverageReductionMode;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineCoverageReductionStateCreateInfoNV::initialize(const safe_VkPipelineCoverageReductionStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
coverageReductionMode = copy_src->coverageReductionMode;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV* in_struct) :
sType(in_struct->sType),
coverageReductionMode(in_struct->coverageReductionMode),
rasterizationSamples(in_struct->rasterizationSamples),
depthStencilSamples(in_struct->depthStencilSamples),
colorSamples(in_struct->colorSamples)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV() :
sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV),
pNext(nullptr)
{}
safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV(const safe_VkFramebufferMixedSamplesCombinationNV& copy_src)
{
sType = copy_src.sType;
coverageReductionMode = copy_src.coverageReductionMode;
rasterizationSamples = copy_src.rasterizationSamples;
depthStencilSamples = copy_src.depthStencilSamples;
colorSamples = copy_src.colorSamples;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkFramebufferMixedSamplesCombinationNV& safe_VkFramebufferMixedSamplesCombinationNV::operator=(const safe_VkFramebufferMixedSamplesCombinationNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
coverageReductionMode = copy_src.coverageReductionMode;
rasterizationSamples = copy_src.rasterizationSamples;
depthStencilSamples = copy_src.depthStencilSamples;
colorSamples = copy_src.colorSamples;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkFramebufferMixedSamplesCombinationNV::~safe_VkFramebufferMixedSamplesCombinationNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkFramebufferMixedSamplesCombinationNV::initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct)
{
sType = in_struct->sType;
coverageReductionMode = in_struct->coverageReductionMode;
rasterizationSamples = in_struct->rasterizationSamples;
depthStencilSamples = in_struct->depthStencilSamples;
colorSamples = in_struct->colorSamples;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkFramebufferMixedSamplesCombinationNV::initialize(const safe_VkFramebufferMixedSamplesCombinationNV* copy_src)
{
sType = copy_src->sType;
coverageReductionMode = copy_src->coverageReductionMode;
rasterizationSamples = copy_src->rasterizationSamples;
depthStencilSamples = copy_src->depthStencilSamples;
colorSamples = copy_src->colorSamples;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct) :
sType(in_struct->sType),
fragmentShaderSampleInterlock(in_struct->fragmentShaderSampleInterlock),
fragmentShaderPixelInterlock(in_struct->fragmentShaderPixelInterlock),
fragmentShaderShadingRateInterlock(in_struct->fragmentShaderShadingRateInterlock)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src)
{
sType = copy_src.sType;
fragmentShaderSampleInterlock = copy_src.fragmentShaderSampleInterlock;
fragmentShaderPixelInterlock = copy_src.fragmentShaderPixelInterlock;
fragmentShaderShadingRateInterlock = copy_src.fragmentShaderShadingRateInterlock;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fragmentShaderSampleInterlock = copy_src.fragmentShaderSampleInterlock;
fragmentShaderPixelInterlock = copy_src.fragmentShaderPixelInterlock;
fragmentShaderShadingRateInterlock = copy_src.fragmentShaderShadingRateInterlock;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::~safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct)
{
sType = in_struct->sType;
fragmentShaderSampleInterlock = in_struct->fragmentShaderSampleInterlock;
fragmentShaderPixelInterlock = in_struct->fragmentShaderPixelInterlock;
fragmentShaderShadingRateInterlock = in_struct->fragmentShaderShadingRateInterlock;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* copy_src)
{
sType = copy_src->sType;
fragmentShaderSampleInterlock = copy_src->fragmentShaderSampleInterlock;
fragmentShaderPixelInterlock = copy_src->fragmentShaderPixelInterlock;
fragmentShaderShadingRateInterlock = copy_src->fragmentShaderShadingRateInterlock;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct) :
sType(in_struct->sType),
ycbcrImageArrays(in_struct->ycbcrImageArrays)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src)
{
sType = copy_src.sType;
ycbcrImageArrays = copy_src.ycbcrImageArrays;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
ycbcrImageArrays = copy_src.ycbcrImageArrays;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::~safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct)
{
sType = in_struct->sType;
ycbcrImageArrays = in_struct->ycbcrImageArrays;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* copy_src)
{
sType = copy_src->sType;
ycbcrImageArrays = copy_src->ycbcrImageArrays;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct) :
sType(in_struct->sType),
provokingVertexLast(in_struct->provokingVertexLast),
transformFeedbackPreservesProvokingVertex(in_struct->transformFeedbackPreservesProvokingVertex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src)
{
sType = copy_src.sType;
provokingVertexLast = copy_src.provokingVertexLast;
transformFeedbackPreservesProvokingVertex = copy_src.transformFeedbackPreservesProvokingVertex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::operator=(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
provokingVertexLast = copy_src.provokingVertexLast;
transformFeedbackPreservesProvokingVertex = copy_src.transformFeedbackPreservesProvokingVertex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::~safe_VkPhysicalDeviceProvokingVertexFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::initialize(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct)
{
sType = in_struct->sType;
provokingVertexLast = in_struct->provokingVertexLast;
transformFeedbackPreservesProvokingVertex = in_struct->transformFeedbackPreservesProvokingVertex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::initialize(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT* copy_src)
{
sType = copy_src->sType;
provokingVertexLast = copy_src->provokingVertexLast;
transformFeedbackPreservesProvokingVertex = copy_src->transformFeedbackPreservesProvokingVertex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct) :
sType(in_struct->sType),
provokingVertexModePerPipeline(in_struct->provokingVertexModePerPipeline),
transformFeedbackPreservesTriangleFanProvokingVertex(in_struct->transformFeedbackPreservesTriangleFanProvokingVertex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src)
{
sType = copy_src.sType;
provokingVertexModePerPipeline = copy_src.provokingVertexModePerPipeline;
transformFeedbackPreservesTriangleFanProvokingVertex = copy_src.transformFeedbackPreservesTriangleFanProvokingVertex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::operator=(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
provokingVertexModePerPipeline = copy_src.provokingVertexModePerPipeline;
transformFeedbackPreservesTriangleFanProvokingVertex = copy_src.transformFeedbackPreservesTriangleFanProvokingVertex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::~safe_VkPhysicalDeviceProvokingVertexPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::initialize(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct)
{
sType = in_struct->sType;
provokingVertexModePerPipeline = in_struct->provokingVertexModePerPipeline;
transformFeedbackPreservesTriangleFanProvokingVertex = in_struct->transformFeedbackPreservesTriangleFanProvokingVertex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::initialize(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT* copy_src)
{
sType = copy_src->sType;
provokingVertexModePerPipeline = copy_src->provokingVertexModePerPipeline;
transformFeedbackPreservesTriangleFanProvokingVertex = copy_src->transformFeedbackPreservesTriangleFanProvokingVertex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct) :
sType(in_struct->sType),
provokingVertexMode(in_struct->provokingVertexMode)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
provokingVertexMode = copy_src.provokingVertexMode;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::operator=(const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
provokingVertexMode = copy_src.provokingVertexMode;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::~safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::initialize(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
provokingVertexMode = in_struct->provokingVertexMode;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::initialize(const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
provokingVertexMode = copy_src->provokingVertexMode;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct) :
sType(in_struct->sType),
fullScreenExclusive(in_struct->fullScreenExclusive)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT() :
sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT),
pNext(nullptr)
{}
safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT(const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src)
{
sType = copy_src.sType;
fullScreenExclusive = copy_src.fullScreenExclusive;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSurfaceFullScreenExclusiveInfoEXT& safe_VkSurfaceFullScreenExclusiveInfoEXT::operator=(const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fullScreenExclusive = copy_src.fullScreenExclusive;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSurfaceFullScreenExclusiveInfoEXT::~safe_VkSurfaceFullScreenExclusiveInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct)
{
sType = in_struct->sType;
fullScreenExclusive = in_struct->fullScreenExclusive;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveInfoEXT* copy_src)
{
sType = copy_src->sType;
fullScreenExclusive = copy_src->fullScreenExclusive;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct) :
sType(in_struct->sType),
fullScreenExclusiveSupported(in_struct->fullScreenExclusiveSupported)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT() :
sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT),
pNext(nullptr)
{}
safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src)
{
sType = copy_src.sType;
fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::operator=(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct)
{
sType = in_struct->sType;
fullScreenExclusiveSupported = in_struct->fullScreenExclusiveSupported;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* copy_src)
{
sType = copy_src->sType;
fullScreenExclusiveSupported = copy_src->fullScreenExclusiveSupported;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct) :
sType(in_struct->sType),
hmonitor(in_struct->hmonitor)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() :
sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT),
pNext(nullptr)
{}
safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src)
{
sType = copy_src.sType;
hmonitor = copy_src.hmonitor;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::operator=(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
hmonitor = copy_src.hmonitor;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct)
{
sType = in_struct->sType;
hmonitor = in_struct->hmonitor;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* copy_src)
{
sType = copy_src->sType;
hmonitor = copy_src->hmonitor;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkHeadlessSurfaceCreateInfoEXT& safe_VkHeadlessSurfaceCreateInfoEXT::operator=(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkHeadlessSurfaceCreateInfoEXT::~safe_VkHeadlessSurfaceCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct) :
sType(in_struct->sType),
rectangularLines(in_struct->rectangularLines),
bresenhamLines(in_struct->bresenhamLines),
smoothLines(in_struct->smoothLines),
stippledRectangularLines(in_struct->stippledRectangularLines),
stippledBresenhamLines(in_struct->stippledBresenhamLines),
stippledSmoothLines(in_struct->stippledSmoothLines)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::safe_VkPhysicalDeviceLineRasterizationFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& copy_src)
{
sType = copy_src.sType;
rectangularLines = copy_src.rectangularLines;
bresenhamLines = copy_src.bresenhamLines;
smoothLines = copy_src.smoothLines;
stippledRectangularLines = copy_src.stippledRectangularLines;
stippledBresenhamLines = copy_src.stippledBresenhamLines;
stippledSmoothLines = copy_src.stippledSmoothLines;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
rectangularLines = copy_src.rectangularLines;
bresenhamLines = copy_src.bresenhamLines;
smoothLines = copy_src.smoothLines;
stippledRectangularLines = copy_src.stippledRectangularLines;
stippledBresenhamLines = copy_src.stippledBresenhamLines;
stippledSmoothLines = copy_src.stippledSmoothLines;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::~safe_VkPhysicalDeviceLineRasterizationFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::initialize(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct)
{
sType = in_struct->sType;
rectangularLines = in_struct->rectangularLines;
bresenhamLines = in_struct->bresenhamLines;
smoothLines = in_struct->smoothLines;
stippledRectangularLines = in_struct->stippledRectangularLines;
stippledBresenhamLines = in_struct->stippledBresenhamLines;
stippledSmoothLines = in_struct->stippledSmoothLines;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT* copy_src)
{
sType = copy_src->sType;
rectangularLines = copy_src->rectangularLines;
bresenhamLines = copy_src->bresenhamLines;
smoothLines = copy_src->smoothLines;
stippledRectangularLines = copy_src->stippledRectangularLines;
stippledBresenhamLines = copy_src->stippledBresenhamLines;
stippledSmoothLines = copy_src->stippledSmoothLines;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct) :
sType(in_struct->sType),
lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::safe_VkPhysicalDeviceLineRasterizationPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& copy_src)
{
sType = copy_src.sType;
lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::operator=(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::~safe_VkPhysicalDeviceLineRasterizationPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::initialize(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct)
{
sType = in_struct->sType;
lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT* copy_src)
{
sType = copy_src->sType;
lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineRasterizationLineStateCreateInfoEXT::safe_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct) :
sType(in_struct->sType),
lineRasterizationMode(in_struct->lineRasterizationMode),
stippledLineEnable(in_struct->stippledLineEnable),
lineStippleFactor(in_struct->lineStippleFactor),
lineStipplePattern(in_struct->lineStipplePattern)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPipelineRasterizationLineStateCreateInfoEXT::safe_VkPipelineRasterizationLineStateCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPipelineRasterizationLineStateCreateInfoEXT::safe_VkPipelineRasterizationLineStateCreateInfoEXT(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
lineRasterizationMode = copy_src.lineRasterizationMode;
stippledLineEnable = copy_src.stippledLineEnable;
lineStippleFactor = copy_src.lineStippleFactor;
lineStipplePattern = copy_src.lineStipplePattern;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPipelineRasterizationLineStateCreateInfoEXT& safe_VkPipelineRasterizationLineStateCreateInfoEXT::operator=(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
lineRasterizationMode = copy_src.lineRasterizationMode;
stippledLineEnable = copy_src.stippledLineEnable;
lineStippleFactor = copy_src.lineStippleFactor;
lineStipplePattern = copy_src.lineStipplePattern;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPipelineRasterizationLineStateCreateInfoEXT::~safe_VkPipelineRasterizationLineStateCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineRasterizationLineStateCreateInfoEXT::initialize(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
lineRasterizationMode = in_struct->lineRasterizationMode;
stippledLineEnable = in_struct->stippledLineEnable;
lineStippleFactor = in_struct->lineStippleFactor;
lineStipplePattern = in_struct->lineStipplePattern;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPipelineRasterizationLineStateCreateInfoEXT::initialize(const safe_VkPipelineRasterizationLineStateCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
lineRasterizationMode = copy_src->lineRasterizationMode;
stippledLineEnable = copy_src->stippledLineEnable;
lineStippleFactor = copy_src->lineStippleFactor;
lineStipplePattern = copy_src->lineStipplePattern;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct) :
sType(in_struct->sType),
shaderBufferFloat32Atomics(in_struct->shaderBufferFloat32Atomics),
shaderBufferFloat32AtomicAdd(in_struct->shaderBufferFloat32AtomicAdd),
shaderBufferFloat64Atomics(in_struct->shaderBufferFloat64Atomics),
shaderBufferFloat64AtomicAdd(in_struct->shaderBufferFloat64AtomicAdd),
shaderSharedFloat32Atomics(in_struct->shaderSharedFloat32Atomics),
shaderSharedFloat32AtomicAdd(in_struct->shaderSharedFloat32AtomicAdd),
shaderSharedFloat64Atomics(in_struct->shaderSharedFloat64Atomics),
shaderSharedFloat64AtomicAdd(in_struct->shaderSharedFloat64AtomicAdd),
shaderImageFloat32Atomics(in_struct->shaderImageFloat32Atomics),
shaderImageFloat32AtomicAdd(in_struct->shaderImageFloat32AtomicAdd),
sparseImageFloat32Atomics(in_struct->sparseImageFloat32Atomics),
sparseImageFloat32AtomicAdd(in_struct->sparseImageFloat32AtomicAdd)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src)
{
sType = copy_src.sType;
shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics;
shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd;
shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics;
shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd;
shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics;
shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd;
shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics;
shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd;
shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics;
shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd;
sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics;
sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::operator=(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics;
shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd;
shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics;
shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd;
shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics;
shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd;
shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics;
shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd;
shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics;
shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd;
sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics;
sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::~safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct)
{
sType = in_struct->sType;
shaderBufferFloat32Atomics = in_struct->shaderBufferFloat32Atomics;
shaderBufferFloat32AtomicAdd = in_struct->shaderBufferFloat32AtomicAdd;
shaderBufferFloat64Atomics = in_struct->shaderBufferFloat64Atomics;
shaderBufferFloat64AtomicAdd = in_struct->shaderBufferFloat64AtomicAdd;
shaderSharedFloat32Atomics = in_struct->shaderSharedFloat32Atomics;
shaderSharedFloat32AtomicAdd = in_struct->shaderSharedFloat32AtomicAdd;
shaderSharedFloat64Atomics = in_struct->shaderSharedFloat64Atomics;
shaderSharedFloat64AtomicAdd = in_struct->shaderSharedFloat64AtomicAdd;
shaderImageFloat32Atomics = in_struct->shaderImageFloat32Atomics;
shaderImageFloat32AtomicAdd = in_struct->shaderImageFloat32AtomicAdd;
sparseImageFloat32Atomics = in_struct->sparseImageFloat32Atomics;
sparseImageFloat32AtomicAdd = in_struct->sparseImageFloat32AtomicAdd;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src)
{
sType = copy_src->sType;
shaderBufferFloat32Atomics = copy_src->shaderBufferFloat32Atomics;
shaderBufferFloat32AtomicAdd = copy_src->shaderBufferFloat32AtomicAdd;
shaderBufferFloat64Atomics = copy_src->shaderBufferFloat64Atomics;
shaderBufferFloat64AtomicAdd = copy_src->shaderBufferFloat64AtomicAdd;
shaderSharedFloat32Atomics = copy_src->shaderSharedFloat32Atomics;
shaderSharedFloat32AtomicAdd = copy_src->shaderSharedFloat32AtomicAdd;
shaderSharedFloat64Atomics = copy_src->shaderSharedFloat64Atomics;
shaderSharedFloat64AtomicAdd = copy_src->shaderSharedFloat64AtomicAdd;
shaderImageFloat32Atomics = copy_src->shaderImageFloat32Atomics;
shaderImageFloat32AtomicAdd = copy_src->shaderImageFloat32AtomicAdd;
sparseImageFloat32Atomics = copy_src->sparseImageFloat32Atomics;
sparseImageFloat32AtomicAdd = copy_src->sparseImageFloat32AtomicAdd;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct) :
sType(in_struct->sType),
indexTypeUint8(in_struct->indexTypeUint8)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& copy_src)
{
sType = copy_src.sType;
indexTypeUint8 = copy_src.indexTypeUint8;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
indexTypeUint8 = copy_src.indexTypeUint8;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::~safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct)
{
sType = in_struct->sType;
indexTypeUint8 = in_struct->indexTypeUint8;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT* copy_src)
{
sType = copy_src->sType;
indexTypeUint8 = copy_src->indexTypeUint8;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct) :
sType(in_struct->sType),
extendedDynamicState(in_struct->extendedDynamicState)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src)
{
sType = copy_src.sType;
extendedDynamicState = copy_src.extendedDynamicState;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::operator=(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
extendedDynamicState = copy_src.extendedDynamicState;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct)
{
sType = in_struct->sType;
extendedDynamicState = in_struct->extendedDynamicState;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src)
{
sType = copy_src->sType;
extendedDynamicState = copy_src->extendedDynamicState;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct) :
sType(in_struct->sType),
shaderDemoteToHelperInvocation(in_struct->shaderDemoteToHelperInvocation)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& copy_src)
{
sType = copy_src.sType;
shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::operator=(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::~safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::initialize(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct)
{
sType = in_struct->sType;
shaderDemoteToHelperInvocation = in_struct->shaderDemoteToHelperInvocation;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* copy_src)
{
sType = copy_src->sType;
shaderDemoteToHelperInvocation = copy_src->shaderDemoteToHelperInvocation;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct) :
sType(in_struct->sType),
maxGraphicsShaderGroupCount(in_struct->maxGraphicsShaderGroupCount),
maxIndirectSequenceCount(in_struct->maxIndirectSequenceCount),
maxIndirectCommandsTokenCount(in_struct->maxIndirectCommandsTokenCount),
maxIndirectCommandsStreamCount(in_struct->maxIndirectCommandsStreamCount),
maxIndirectCommandsTokenOffset(in_struct->maxIndirectCommandsTokenOffset),
maxIndirectCommandsStreamStride(in_struct->maxIndirectCommandsStreamStride),
minSequencesCountBufferOffsetAlignment(in_struct->minSequencesCountBufferOffsetAlignment),
minSequencesIndexBufferOffsetAlignment(in_struct->minSequencesIndexBufferOffsetAlignment),
minIndirectCommandsBufferOffsetAlignment(in_struct->minIndirectCommandsBufferOffsetAlignment)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src)
{
sType = copy_src.sType;
maxGraphicsShaderGroupCount = copy_src.maxGraphicsShaderGroupCount;
maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount;
maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount;
maxIndirectCommandsStreamCount = copy_src.maxIndirectCommandsStreamCount;
maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset;
maxIndirectCommandsStreamStride = copy_src.maxIndirectCommandsStreamStride;
minSequencesCountBufferOffsetAlignment = copy_src.minSequencesCountBufferOffsetAlignment;
minSequencesIndexBufferOffsetAlignment = copy_src.minSequencesIndexBufferOffsetAlignment;
minIndirectCommandsBufferOffsetAlignment = copy_src.minIndirectCommandsBufferOffsetAlignment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::operator=(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxGraphicsShaderGroupCount = copy_src.maxGraphicsShaderGroupCount;
maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount;
maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount;
maxIndirectCommandsStreamCount = copy_src.maxIndirectCommandsStreamCount;
maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset;
maxIndirectCommandsStreamStride = copy_src.maxIndirectCommandsStreamStride;
minSequencesCountBufferOffsetAlignment = copy_src.minSequencesCountBufferOffsetAlignment;
minSequencesIndexBufferOffsetAlignment = copy_src.minSequencesIndexBufferOffsetAlignment;
minIndirectCommandsBufferOffsetAlignment = copy_src.minIndirectCommandsBufferOffsetAlignment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::initialize(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct)
{
sType = in_struct->sType;
maxGraphicsShaderGroupCount = in_struct->maxGraphicsShaderGroupCount;
maxIndirectSequenceCount = in_struct->maxIndirectSequenceCount;
maxIndirectCommandsTokenCount = in_struct->maxIndirectCommandsTokenCount;
maxIndirectCommandsStreamCount = in_struct->maxIndirectCommandsStreamCount;
maxIndirectCommandsTokenOffset = in_struct->maxIndirectCommandsTokenOffset;
maxIndirectCommandsStreamStride = in_struct->maxIndirectCommandsStreamStride;
minSequencesCountBufferOffsetAlignment = in_struct->minSequencesCountBufferOffsetAlignment;
minSequencesIndexBufferOffsetAlignment = in_struct->minSequencesIndexBufferOffsetAlignment;
minIndirectCommandsBufferOffsetAlignment = in_struct->minIndirectCommandsBufferOffsetAlignment;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* copy_src)
{
sType = copy_src->sType;
maxGraphicsShaderGroupCount = copy_src->maxGraphicsShaderGroupCount;
maxIndirectSequenceCount = copy_src->maxIndirectSequenceCount;
maxIndirectCommandsTokenCount = copy_src->maxIndirectCommandsTokenCount;
maxIndirectCommandsStreamCount = copy_src->maxIndirectCommandsStreamCount;
maxIndirectCommandsTokenOffset = copy_src->maxIndirectCommandsTokenOffset;
maxIndirectCommandsStreamStride = copy_src->maxIndirectCommandsStreamStride;
minSequencesCountBufferOffsetAlignment = copy_src->minSequencesCountBufferOffsetAlignment;
minSequencesIndexBufferOffsetAlignment = copy_src->minSequencesIndexBufferOffsetAlignment;
minIndirectCommandsBufferOffsetAlignment = copy_src->minIndirectCommandsBufferOffsetAlignment;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct) :
sType(in_struct->sType),
deviceGeneratedCommands(in_struct->deviceGeneratedCommands)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src)
{
sType = copy_src.sType;
deviceGeneratedCommands = copy_src.deviceGeneratedCommands;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::operator=(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceGeneratedCommands = copy_src.deviceGeneratedCommands;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::initialize(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct)
{
sType = in_struct->sType;
deviceGeneratedCommands = in_struct->deviceGeneratedCommands;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* copy_src)
{
sType = copy_src->sType;
deviceGeneratedCommands = copy_src->deviceGeneratedCommands;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV* in_struct) :
sType(in_struct->sType),
stageCount(in_struct->stageCount),
pStages(nullptr),
pVertexInputState(nullptr),
pTessellationState(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (stageCount && in_struct->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&in_struct->pStages[i]);
}
}
if (in_struct->pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
if (in_struct->pTessellationState)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
}
safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV),
pNext(nullptr),
pStages(nullptr),
pVertexInputState(nullptr),
pTessellationState(nullptr)
{}
safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV(const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src)
{
sType = copy_src.sType;
stageCount = copy_src.stageCount;
pStages = nullptr;
pVertexInputState = nullptr;
pTessellationState = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (stageCount && copy_src.pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src.pStages[i]);
}
}
if (copy_src.pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
if (copy_src.pTessellationState)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
}
safe_VkGraphicsShaderGroupCreateInfoNV& safe_VkGraphicsShaderGroupCreateInfoNV::operator=(const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pStages)
delete[] pStages;
if (pVertexInputState)
delete pVertexInputState;
if (pTessellationState)
delete pTessellationState;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
stageCount = copy_src.stageCount;
pStages = nullptr;
pVertexInputState = nullptr;
pTessellationState = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (stageCount && copy_src.pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src.pStages[i]);
}
}
if (copy_src.pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
if (copy_src.pTessellationState)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
return *this;
}
safe_VkGraphicsShaderGroupCreateInfoNV::~safe_VkGraphicsShaderGroupCreateInfoNV()
{
if (pStages)
delete[] pStages;
if (pVertexInputState)
delete pVertexInputState;
if (pTessellationState)
delete pTessellationState;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkGraphicsShaderGroupCreateInfoNV::initialize(const VkGraphicsShaderGroupCreateInfoNV* in_struct)
{
sType = in_struct->sType;
stageCount = in_struct->stageCount;
pStages = nullptr;
pVertexInputState = nullptr;
pTessellationState = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (stageCount && in_struct->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&in_struct->pStages[i]);
}
}
if (in_struct->pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
if (in_struct->pTessellationState)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
}
void safe_VkGraphicsShaderGroupCreateInfoNV::initialize(const safe_VkGraphicsShaderGroupCreateInfoNV* copy_src)
{
sType = copy_src->sType;
stageCount = copy_src->stageCount;
pStages = nullptr;
pVertexInputState = nullptr;
pTessellationState = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (stageCount && copy_src->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src->pStages[i]);
}
}
if (copy_src->pVertexInputState)
pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src->pVertexInputState);
if (copy_src->pTessellationState)
pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src->pTessellationState);
}
safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct) :
sType(in_struct->sType),
groupCount(in_struct->groupCount),
pGroups(nullptr),
pipelineCount(in_struct->pipelineCount),
pPipelines(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (groupCount && in_struct->pGroups) {
pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&in_struct->pGroups[i]);
}
}
if (pipelineCount && in_struct->pPipelines) {
pPipelines = new VkPipeline[pipelineCount];
for (uint32_t i = 0; i < pipelineCount; ++i) {
pPipelines[i] = in_struct->pPipelines[i];
}
}
}
safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV),
pNext(nullptr),
pGroups(nullptr),
pPipelines(nullptr)
{}
safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src)
{
sType = copy_src.sType;
groupCount = copy_src.groupCount;
pGroups = nullptr;
pipelineCount = copy_src.pipelineCount;
pPipelines = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (groupCount && copy_src.pGroups) {
pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src.pGroups[i]);
}
}
if (pipelineCount && copy_src.pPipelines) {
pPipelines = new VkPipeline[pipelineCount];
for (uint32_t i = 0; i < pipelineCount; ++i) {
pPipelines[i] = copy_src.pPipelines[i];
}
}
}
safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::operator=(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pGroups)
delete[] pGroups;
if (pPipelines)
delete[] pPipelines;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
groupCount = copy_src.groupCount;
pGroups = nullptr;
pipelineCount = copy_src.pipelineCount;
pPipelines = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (groupCount && copy_src.pGroups) {
pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src.pGroups[i]);
}
}
if (pipelineCount && copy_src.pPipelines) {
pPipelines = new VkPipeline[pipelineCount];
for (uint32_t i = 0; i < pipelineCount; ++i) {
pPipelines[i] = copy_src.pPipelines[i];
}
}
return *this;
}
safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::~safe_VkGraphicsPipelineShaderGroupsCreateInfoNV()
{
if (pGroups)
delete[] pGroups;
if (pPipelines)
delete[] pPipelines;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::initialize(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct)
{
sType = in_struct->sType;
groupCount = in_struct->groupCount;
pGroups = nullptr;
pipelineCount = in_struct->pipelineCount;
pPipelines = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (groupCount && in_struct->pGroups) {
pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&in_struct->pGroups[i]);
}
}
if (pipelineCount && in_struct->pPipelines) {
pPipelines = new VkPipeline[pipelineCount];
for (uint32_t i = 0; i < pipelineCount; ++i) {
pPipelines[i] = in_struct->pPipelines[i];
}
}
}
void safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::initialize(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV* copy_src)
{
sType = copy_src->sType;
groupCount = copy_src->groupCount;
pGroups = nullptr;
pipelineCount = copy_src->pipelineCount;
pPipelines = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (groupCount && copy_src->pGroups) {
pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src->pGroups[i]);
}
}
if (pipelineCount && copy_src->pPipelines) {
pPipelines = new VkPipeline[pipelineCount];
for (uint32_t i = 0; i < pipelineCount; ++i) {
pPipelines[i] = copy_src->pPipelines[i];
}
}
}
safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV* in_struct) :
sType(in_struct->sType),
tokenType(in_struct->tokenType),
stream(in_struct->stream),
offset(in_struct->offset),
vertexBindingUnit(in_struct->vertexBindingUnit),
vertexDynamicStride(in_struct->vertexDynamicStride),
pushconstantPipelineLayout(in_struct->pushconstantPipelineLayout),
pushconstantShaderStageFlags(in_struct->pushconstantShaderStageFlags),
pushconstantOffset(in_struct->pushconstantOffset),
pushconstantSize(in_struct->pushconstantSize),
indirectStateFlags(in_struct->indirectStateFlags),
indexTypeCount(in_struct->indexTypeCount),
pIndexTypes(nullptr),
pIndexTypeValues(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pIndexTypes) {
pIndexTypes = new VkIndexType[in_struct->indexTypeCount];
memcpy ((void *)pIndexTypes, (void *)in_struct->pIndexTypes, sizeof(VkIndexType)*in_struct->indexTypeCount);
}
if (in_struct->pIndexTypeValues) {
pIndexTypeValues = new uint32_t[in_struct->indexTypeCount];
memcpy ((void *)pIndexTypeValues, (void *)in_struct->pIndexTypeValues, sizeof(uint32_t)*in_struct->indexTypeCount);
}
}
safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV() :
sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV),
pNext(nullptr),
pIndexTypes(nullptr),
pIndexTypeValues(nullptr)
{}
safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV(const safe_VkIndirectCommandsLayoutTokenNV& copy_src)
{
sType = copy_src.sType;
tokenType = copy_src.tokenType;
stream = copy_src.stream;
offset = copy_src.offset;
vertexBindingUnit = copy_src.vertexBindingUnit;
vertexDynamicStride = copy_src.vertexDynamicStride;
pushconstantPipelineLayout = copy_src.pushconstantPipelineLayout;
pushconstantShaderStageFlags = copy_src.pushconstantShaderStageFlags;
pushconstantOffset = copy_src.pushconstantOffset;
pushconstantSize = copy_src.pushconstantSize;
indirectStateFlags = copy_src.indirectStateFlags;
indexTypeCount = copy_src.indexTypeCount;
pIndexTypes = nullptr;
pIndexTypeValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pIndexTypes) {
pIndexTypes = new VkIndexType[copy_src.indexTypeCount];
memcpy ((void *)pIndexTypes, (void *)copy_src.pIndexTypes, sizeof(VkIndexType)*copy_src.indexTypeCount);
}
if (copy_src.pIndexTypeValues) {
pIndexTypeValues = new uint32_t[copy_src.indexTypeCount];
memcpy ((void *)pIndexTypeValues, (void *)copy_src.pIndexTypeValues, sizeof(uint32_t)*copy_src.indexTypeCount);
}
}
safe_VkIndirectCommandsLayoutTokenNV& safe_VkIndirectCommandsLayoutTokenNV::operator=(const safe_VkIndirectCommandsLayoutTokenNV& copy_src)
{
if (&copy_src == this) return *this;
if (pIndexTypes)
delete[] pIndexTypes;
if (pIndexTypeValues)
delete[] pIndexTypeValues;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
tokenType = copy_src.tokenType;
stream = copy_src.stream;
offset = copy_src.offset;
vertexBindingUnit = copy_src.vertexBindingUnit;
vertexDynamicStride = copy_src.vertexDynamicStride;
pushconstantPipelineLayout = copy_src.pushconstantPipelineLayout;
pushconstantShaderStageFlags = copy_src.pushconstantShaderStageFlags;
pushconstantOffset = copy_src.pushconstantOffset;
pushconstantSize = copy_src.pushconstantSize;
indirectStateFlags = copy_src.indirectStateFlags;
indexTypeCount = copy_src.indexTypeCount;
pIndexTypes = nullptr;
pIndexTypeValues = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pIndexTypes) {
pIndexTypes = new VkIndexType[copy_src.indexTypeCount];
memcpy ((void *)pIndexTypes, (void *)copy_src.pIndexTypes, sizeof(VkIndexType)*copy_src.indexTypeCount);
}
if (copy_src.pIndexTypeValues) {
pIndexTypeValues = new uint32_t[copy_src.indexTypeCount];
memcpy ((void *)pIndexTypeValues, (void *)copy_src.pIndexTypeValues, sizeof(uint32_t)*copy_src.indexTypeCount);
}
return *this;
}
safe_VkIndirectCommandsLayoutTokenNV::~safe_VkIndirectCommandsLayoutTokenNV()
{
if (pIndexTypes)
delete[] pIndexTypes;
if (pIndexTypeValues)
delete[] pIndexTypeValues;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkIndirectCommandsLayoutTokenNV::initialize(const VkIndirectCommandsLayoutTokenNV* in_struct)
{
sType = in_struct->sType;
tokenType = in_struct->tokenType;
stream = in_struct->stream;
offset = in_struct->offset;
vertexBindingUnit = in_struct->vertexBindingUnit;
vertexDynamicStride = in_struct->vertexDynamicStride;
pushconstantPipelineLayout = in_struct->pushconstantPipelineLayout;
pushconstantShaderStageFlags = in_struct->pushconstantShaderStageFlags;
pushconstantOffset = in_struct->pushconstantOffset;
pushconstantSize = in_struct->pushconstantSize;
indirectStateFlags = in_struct->indirectStateFlags;
indexTypeCount = in_struct->indexTypeCount;
pIndexTypes = nullptr;
pIndexTypeValues = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pIndexTypes) {
pIndexTypes = new VkIndexType[in_struct->indexTypeCount];
memcpy ((void *)pIndexTypes, (void *)in_struct->pIndexTypes, sizeof(VkIndexType)*in_struct->indexTypeCount);
}
if (in_struct->pIndexTypeValues) {
pIndexTypeValues = new uint32_t[in_struct->indexTypeCount];
memcpy ((void *)pIndexTypeValues, (void *)in_struct->pIndexTypeValues, sizeof(uint32_t)*in_struct->indexTypeCount);
}
}
void safe_VkIndirectCommandsLayoutTokenNV::initialize(const safe_VkIndirectCommandsLayoutTokenNV* copy_src)
{
sType = copy_src->sType;
tokenType = copy_src->tokenType;
stream = copy_src->stream;
offset = copy_src->offset;
vertexBindingUnit = copy_src->vertexBindingUnit;
vertexDynamicStride = copy_src->vertexDynamicStride;
pushconstantPipelineLayout = copy_src->pushconstantPipelineLayout;
pushconstantShaderStageFlags = copy_src->pushconstantShaderStageFlags;
pushconstantOffset = copy_src->pushconstantOffset;
pushconstantSize = copy_src->pushconstantSize;
indirectStateFlags = copy_src->indirectStateFlags;
indexTypeCount = copy_src->indexTypeCount;
pIndexTypes = nullptr;
pIndexTypeValues = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pIndexTypes) {
pIndexTypes = new VkIndexType[copy_src->indexTypeCount];
memcpy ((void *)pIndexTypes, (void *)copy_src->pIndexTypes, sizeof(VkIndexType)*copy_src->indexTypeCount);
}
if (copy_src->pIndexTypeValues) {
pIndexTypeValues = new uint32_t[copy_src->indexTypeCount];
memcpy ((void *)pIndexTypeValues, (void *)copy_src->pIndexTypeValues, sizeof(uint32_t)*copy_src->indexTypeCount);
}
}
safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
pipelineBindPoint(in_struct->pipelineBindPoint),
tokenCount(in_struct->tokenCount),
pTokens(nullptr),
streamCount(in_struct->streamCount),
pStreamStrides(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (tokenCount && in_struct->pTokens) {
pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
for (uint32_t i = 0; i < tokenCount; ++i) {
pTokens[i].initialize(&in_struct->pTokens[i]);
}
}
if (in_struct->pStreamStrides) {
pStreamStrides = new uint32_t[in_struct->streamCount];
memcpy ((void *)pStreamStrides, (void *)in_struct->pStreamStrides, sizeof(uint32_t)*in_struct->streamCount);
}
}
safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV),
pNext(nullptr),
pTokens(nullptr),
pStreamStrides(nullptr)
{}
safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV(const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pipelineBindPoint = copy_src.pipelineBindPoint;
tokenCount = copy_src.tokenCount;
pTokens = nullptr;
streamCount = copy_src.streamCount;
pStreamStrides = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (tokenCount && copy_src.pTokens) {
pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
for (uint32_t i = 0; i < tokenCount; ++i) {
pTokens[i].initialize(&copy_src.pTokens[i]);
}
}
if (copy_src.pStreamStrides) {
pStreamStrides = new uint32_t[copy_src.streamCount];
memcpy ((void *)pStreamStrides, (void *)copy_src.pStreamStrides, sizeof(uint32_t)*copy_src.streamCount);
}
}
safe_VkIndirectCommandsLayoutCreateInfoNV& safe_VkIndirectCommandsLayoutCreateInfoNV::operator=(const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pTokens)
delete[] pTokens;
if (pStreamStrides)
delete[] pStreamStrides;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pipelineBindPoint = copy_src.pipelineBindPoint;
tokenCount = copy_src.tokenCount;
pTokens = nullptr;
streamCount = copy_src.streamCount;
pStreamStrides = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (tokenCount && copy_src.pTokens) {
pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
for (uint32_t i = 0; i < tokenCount; ++i) {
pTokens[i].initialize(&copy_src.pTokens[i]);
}
}
if (copy_src.pStreamStrides) {
pStreamStrides = new uint32_t[copy_src.streamCount];
memcpy ((void *)pStreamStrides, (void *)copy_src.pStreamStrides, sizeof(uint32_t)*copy_src.streamCount);
}
return *this;
}
safe_VkIndirectCommandsLayoutCreateInfoNV::~safe_VkIndirectCommandsLayoutCreateInfoNV()
{
if (pTokens)
delete[] pTokens;
if (pStreamStrides)
delete[] pStreamStrides;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkIndirectCommandsLayoutCreateInfoNV::initialize(const VkIndirectCommandsLayoutCreateInfoNV* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pipelineBindPoint = in_struct->pipelineBindPoint;
tokenCount = in_struct->tokenCount;
pTokens = nullptr;
streamCount = in_struct->streamCount;
pStreamStrides = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (tokenCount && in_struct->pTokens) {
pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
for (uint32_t i = 0; i < tokenCount; ++i) {
pTokens[i].initialize(&in_struct->pTokens[i]);
}
}
if (in_struct->pStreamStrides) {
pStreamStrides = new uint32_t[in_struct->streamCount];
memcpy ((void *)pStreamStrides, (void *)in_struct->pStreamStrides, sizeof(uint32_t)*in_struct->streamCount);
}
}
void safe_VkIndirectCommandsLayoutCreateInfoNV::initialize(const safe_VkIndirectCommandsLayoutCreateInfoNV* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pipelineBindPoint = copy_src->pipelineBindPoint;
tokenCount = copy_src->tokenCount;
pTokens = nullptr;
streamCount = copy_src->streamCount;
pStreamStrides = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (tokenCount && copy_src->pTokens) {
pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
for (uint32_t i = 0; i < tokenCount; ++i) {
pTokens[i].initialize(&copy_src->pTokens[i]);
}
}
if (copy_src->pStreamStrides) {
pStreamStrides = new uint32_t[copy_src->streamCount];
memcpy ((void *)pStreamStrides, (void *)copy_src->pStreamStrides, sizeof(uint32_t)*copy_src->streamCount);
}
}
safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV* in_struct) :
sType(in_struct->sType),
pipelineBindPoint(in_struct->pipelineBindPoint),
pipeline(in_struct->pipeline),
indirectCommandsLayout(in_struct->indirectCommandsLayout),
streamCount(in_struct->streamCount),
pStreams(nullptr),
sequencesCount(in_struct->sequencesCount),
preprocessBuffer(in_struct->preprocessBuffer),
preprocessOffset(in_struct->preprocessOffset),
preprocessSize(in_struct->preprocessSize),
sequencesCountBuffer(in_struct->sequencesCountBuffer),
sequencesCountOffset(in_struct->sequencesCountOffset),
sequencesIndexBuffer(in_struct->sequencesIndexBuffer),
sequencesIndexOffset(in_struct->sequencesIndexOffset)
{
pNext = SafePnextCopy(in_struct->pNext);
if (streamCount && in_struct->pStreams) {
pStreams = new VkIndirectCommandsStreamNV[streamCount];
for (uint32_t i = 0; i < streamCount; ++i) {
pStreams[i] = in_struct->pStreams[i];
}
}
}
safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV() :
sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV),
pNext(nullptr),
pStreams(nullptr)
{}
safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV(const safe_VkGeneratedCommandsInfoNV& copy_src)
{
sType = copy_src.sType;
pipelineBindPoint = copy_src.pipelineBindPoint;
pipeline = copy_src.pipeline;
indirectCommandsLayout = copy_src.indirectCommandsLayout;
streamCount = copy_src.streamCount;
pStreams = nullptr;
sequencesCount = copy_src.sequencesCount;
preprocessBuffer = copy_src.preprocessBuffer;
preprocessOffset = copy_src.preprocessOffset;
preprocessSize = copy_src.preprocessSize;
sequencesCountBuffer = copy_src.sequencesCountBuffer;
sequencesCountOffset = copy_src.sequencesCountOffset;
sequencesIndexBuffer = copy_src.sequencesIndexBuffer;
sequencesIndexOffset = copy_src.sequencesIndexOffset;
pNext = SafePnextCopy(copy_src.pNext);
if (streamCount && copy_src.pStreams) {
pStreams = new VkIndirectCommandsStreamNV[streamCount];
for (uint32_t i = 0; i < streamCount; ++i) {
pStreams[i] = copy_src.pStreams[i];
}
}
}
safe_VkGeneratedCommandsInfoNV& safe_VkGeneratedCommandsInfoNV::operator=(const safe_VkGeneratedCommandsInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pStreams)
delete[] pStreams;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pipelineBindPoint = copy_src.pipelineBindPoint;
pipeline = copy_src.pipeline;
indirectCommandsLayout = copy_src.indirectCommandsLayout;
streamCount = copy_src.streamCount;
pStreams = nullptr;
sequencesCount = copy_src.sequencesCount;
preprocessBuffer = copy_src.preprocessBuffer;
preprocessOffset = copy_src.preprocessOffset;
preprocessSize = copy_src.preprocessSize;
sequencesCountBuffer = copy_src.sequencesCountBuffer;
sequencesCountOffset = copy_src.sequencesCountOffset;
sequencesIndexBuffer = copy_src.sequencesIndexBuffer;
sequencesIndexOffset = copy_src.sequencesIndexOffset;
pNext = SafePnextCopy(copy_src.pNext);
if (streamCount && copy_src.pStreams) {
pStreams = new VkIndirectCommandsStreamNV[streamCount];
for (uint32_t i = 0; i < streamCount; ++i) {
pStreams[i] = copy_src.pStreams[i];
}
}
return *this;
}
safe_VkGeneratedCommandsInfoNV::~safe_VkGeneratedCommandsInfoNV()
{
if (pStreams)
delete[] pStreams;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkGeneratedCommandsInfoNV::initialize(const VkGeneratedCommandsInfoNV* in_struct)
{
sType = in_struct->sType;
pipelineBindPoint = in_struct->pipelineBindPoint;
pipeline = in_struct->pipeline;
indirectCommandsLayout = in_struct->indirectCommandsLayout;
streamCount = in_struct->streamCount;
pStreams = nullptr;
sequencesCount = in_struct->sequencesCount;
preprocessBuffer = in_struct->preprocessBuffer;
preprocessOffset = in_struct->preprocessOffset;
preprocessSize = in_struct->preprocessSize;
sequencesCountBuffer = in_struct->sequencesCountBuffer;
sequencesCountOffset = in_struct->sequencesCountOffset;
sequencesIndexBuffer = in_struct->sequencesIndexBuffer;
sequencesIndexOffset = in_struct->sequencesIndexOffset;
pNext = SafePnextCopy(in_struct->pNext);
if (streamCount && in_struct->pStreams) {
pStreams = new VkIndirectCommandsStreamNV[streamCount];
for (uint32_t i = 0; i < streamCount; ++i) {
pStreams[i] = in_struct->pStreams[i];
}
}
}
void safe_VkGeneratedCommandsInfoNV::initialize(const safe_VkGeneratedCommandsInfoNV* copy_src)
{
sType = copy_src->sType;
pipelineBindPoint = copy_src->pipelineBindPoint;
pipeline = copy_src->pipeline;
indirectCommandsLayout = copy_src->indirectCommandsLayout;
streamCount = copy_src->streamCount;
pStreams = nullptr;
sequencesCount = copy_src->sequencesCount;
preprocessBuffer = copy_src->preprocessBuffer;
preprocessOffset = copy_src->preprocessOffset;
preprocessSize = copy_src->preprocessSize;
sequencesCountBuffer = copy_src->sequencesCountBuffer;
sequencesCountOffset = copy_src->sequencesCountOffset;
sequencesIndexBuffer = copy_src->sequencesIndexBuffer;
sequencesIndexOffset = copy_src->sequencesIndexOffset;
pNext = SafePnextCopy(copy_src->pNext);
if (streamCount && copy_src->pStreams) {
pStreams = new VkIndirectCommandsStreamNV[streamCount];
for (uint32_t i = 0; i < streamCount; ++i) {
pStreams[i] = copy_src->pStreams[i];
}
}
}
safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct) :
sType(in_struct->sType),
pipelineBindPoint(in_struct->pipelineBindPoint),
pipeline(in_struct->pipeline),
indirectCommandsLayout(in_struct->indirectCommandsLayout),
maxSequencesCount(in_struct->maxSequencesCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV() :
sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV),
pNext(nullptr)
{}
safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src)
{
sType = copy_src.sType;
pipelineBindPoint = copy_src.pipelineBindPoint;
pipeline = copy_src.pipeline;
indirectCommandsLayout = copy_src.indirectCommandsLayout;
maxSequencesCount = copy_src.maxSequencesCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkGeneratedCommandsMemoryRequirementsInfoNV& safe_VkGeneratedCommandsMemoryRequirementsInfoNV::operator=(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pipelineBindPoint = copy_src.pipelineBindPoint;
pipeline = copy_src.pipeline;
indirectCommandsLayout = copy_src.indirectCommandsLayout;
maxSequencesCount = copy_src.maxSequencesCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkGeneratedCommandsMemoryRequirementsInfoNV::~safe_VkGeneratedCommandsMemoryRequirementsInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkGeneratedCommandsMemoryRequirementsInfoNV::initialize(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct)
{
sType = in_struct->sType;
pipelineBindPoint = in_struct->pipelineBindPoint;
pipeline = in_struct->pipeline;
indirectCommandsLayout = in_struct->indirectCommandsLayout;
maxSequencesCount = in_struct->maxSequencesCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkGeneratedCommandsMemoryRequirementsInfoNV::initialize(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV* copy_src)
{
sType = copy_src->sType;
pipelineBindPoint = copy_src->pipelineBindPoint;
pipeline = copy_src->pipeline;
indirectCommandsLayout = copy_src->indirectCommandsLayout;
maxSequencesCount = copy_src->maxSequencesCount;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct) :
sType(in_struct->sType),
inheritedViewportScissor2D(in_struct->inheritedViewportScissor2D)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src)
{
sType = copy_src.sType;
inheritedViewportScissor2D = copy_src.inheritedViewportScissor2D;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::operator=(const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
inheritedViewportScissor2D = copy_src.inheritedViewportScissor2D;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::~safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::initialize(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct)
{
sType = in_struct->sType;
inheritedViewportScissor2D = in_struct->inheritedViewportScissor2D;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::initialize(const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* copy_src)
{
sType = copy_src->sType;
inheritedViewportScissor2D = copy_src->inheritedViewportScissor2D;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV(const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct) :
sType(in_struct->sType),
viewportScissor2D(in_struct->viewportScissor2D),
viewportDepthCount(in_struct->viewportDepthCount),
pViewportDepths(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewportDepths) {
pViewportDepths = new VkViewport(*in_struct->pViewportDepths);
}
}
safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV() :
sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV),
pNext(nullptr),
pViewportDepths(nullptr)
{}
safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV(const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src)
{
sType = copy_src.sType;
viewportScissor2D = copy_src.viewportScissor2D;
viewportDepthCount = copy_src.viewportDepthCount;
pViewportDepths = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewportDepths) {
pViewportDepths = new VkViewport(*copy_src.pViewportDepths);
}
}
safe_VkCommandBufferInheritanceViewportScissorInfoNV& safe_VkCommandBufferInheritanceViewportScissorInfoNV::operator=(const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pViewportDepths)
delete pViewportDepths;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
viewportScissor2D = copy_src.viewportScissor2D;
viewportDepthCount = copy_src.viewportDepthCount;
pViewportDepths = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pViewportDepths) {
pViewportDepths = new VkViewport(*copy_src.pViewportDepths);
}
return *this;
}
safe_VkCommandBufferInheritanceViewportScissorInfoNV::~safe_VkCommandBufferInheritanceViewportScissorInfoNV()
{
if (pViewportDepths)
delete pViewportDepths;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCommandBufferInheritanceViewportScissorInfoNV::initialize(const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct)
{
sType = in_struct->sType;
viewportScissor2D = in_struct->viewportScissor2D;
viewportDepthCount = in_struct->viewportDepthCount;
pViewportDepths = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pViewportDepths) {
pViewportDepths = new VkViewport(*in_struct->pViewportDepths);
}
}
void safe_VkCommandBufferInheritanceViewportScissorInfoNV::initialize(const safe_VkCommandBufferInheritanceViewportScissorInfoNV* copy_src)
{
sType = copy_src->sType;
viewportScissor2D = copy_src->viewportScissor2D;
viewportDepthCount = copy_src->viewportDepthCount;
pViewportDepths = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pViewportDepths) {
pViewportDepths = new VkViewport(*copy_src->pViewportDepths);
}
}
safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct) :
sType(in_struct->sType),
texelBufferAlignment(in_struct->texelBufferAlignment)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src)
{
sType = copy_src.sType;
texelBufferAlignment = copy_src.texelBufferAlignment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
texelBufferAlignment = copy_src.texelBufferAlignment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::~safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct)
{
sType = in_struct->sType;
texelBufferAlignment = in_struct->texelBufferAlignment;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* copy_src)
{
sType = copy_src->sType;
texelBufferAlignment = copy_src->texelBufferAlignment;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* in_struct) :
sType(in_struct->sType),
storageTexelBufferOffsetAlignmentBytes(in_struct->storageTexelBufferOffsetAlignmentBytes),
storageTexelBufferOffsetSingleTexelAlignment(in_struct->storageTexelBufferOffsetSingleTexelAlignment),
uniformTexelBufferOffsetAlignmentBytes(in_struct->uniformTexelBufferOffsetAlignmentBytes),
uniformTexelBufferOffsetSingleTexelAlignment(in_struct->uniformTexelBufferOffsetSingleTexelAlignment)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& copy_src)
{
sType = copy_src.sType;
storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes;
storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment;
uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes;
uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::operator=(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes;
storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment;
uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes;
uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::~safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::initialize(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* in_struct)
{
sType = in_struct->sType;
storageTexelBufferOffsetAlignmentBytes = in_struct->storageTexelBufferOffsetAlignmentBytes;
storageTexelBufferOffsetSingleTexelAlignment = in_struct->storageTexelBufferOffsetSingleTexelAlignment;
uniformTexelBufferOffsetAlignmentBytes = in_struct->uniformTexelBufferOffsetAlignmentBytes;
uniformTexelBufferOffsetSingleTexelAlignment = in_struct->uniformTexelBufferOffsetSingleTexelAlignment;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* copy_src)
{
sType = copy_src->sType;
storageTexelBufferOffsetAlignmentBytes = copy_src->storageTexelBufferOffsetAlignmentBytes;
storageTexelBufferOffsetSingleTexelAlignment = copy_src->storageTexelBufferOffsetSingleTexelAlignment;
uniformTexelBufferOffsetAlignmentBytes = copy_src->uniformTexelBufferOffsetAlignmentBytes;
uniformTexelBufferOffsetSingleTexelAlignment = copy_src->uniformTexelBufferOffsetSingleTexelAlignment;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM* in_struct) :
sType(in_struct->sType),
transform(in_struct->transform)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM() :
sType(VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM),
pNext(nullptr)
{}
safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM(const safe_VkRenderPassTransformBeginInfoQCOM& copy_src)
{
sType = copy_src.sType;
transform = copy_src.transform;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkRenderPassTransformBeginInfoQCOM& safe_VkRenderPassTransformBeginInfoQCOM::operator=(const safe_VkRenderPassTransformBeginInfoQCOM& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
transform = copy_src.transform;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkRenderPassTransformBeginInfoQCOM::~safe_VkRenderPassTransformBeginInfoQCOM()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRenderPassTransformBeginInfoQCOM::initialize(const VkRenderPassTransformBeginInfoQCOM* in_struct)
{
sType = in_struct->sType;
transform = in_struct->transform;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkRenderPassTransformBeginInfoQCOM::initialize(const safe_VkRenderPassTransformBeginInfoQCOM* copy_src)
{
sType = copy_src->sType;
transform = copy_src->transform;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct) :
sType(in_struct->sType),
transform(in_struct->transform),
renderArea(in_struct->renderArea)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM() :
sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM),
pNext(nullptr)
{}
safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src)
{
sType = copy_src.sType;
transform = copy_src.transform;
renderArea = copy_src.renderArea;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::operator=(const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
transform = copy_src.transform;
renderArea = copy_src.renderArea;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::~safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::initialize(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct)
{
sType = in_struct->sType;
transform = in_struct->transform;
renderArea = in_struct->renderArea;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::initialize(const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* copy_src)
{
sType = copy_src->sType;
transform = copy_src->transform;
renderArea = copy_src->renderArea;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct) :
sType(in_struct->sType),
deviceMemoryReport(in_struct->deviceMemoryReport)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src)
{
sType = copy_src.sType;
deviceMemoryReport = copy_src.deviceMemoryReport;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::operator=(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
deviceMemoryReport = copy_src.deviceMemoryReport;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::~safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::initialize(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct)
{
sType = in_struct->sType;
deviceMemoryReport = in_struct->deviceMemoryReport;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::initialize(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* copy_src)
{
sType = copy_src->sType;
deviceMemoryReport = copy_src->deviceMemoryReport;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
type(in_struct->type),
memoryObjectId(in_struct->memoryObjectId),
size(in_struct->size),
objectType(in_struct->objectType),
objectHandle(in_struct->objectHandle),
heapIndex(in_struct->heapIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT() :
sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT),
pNext(nullptr)
{}
safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT(const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
type = copy_src.type;
memoryObjectId = copy_src.memoryObjectId;
size = copy_src.size;
objectType = copy_src.objectType;
objectHandle = copy_src.objectHandle;
heapIndex = copy_src.heapIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceMemoryReportCallbackDataEXT& safe_VkDeviceMemoryReportCallbackDataEXT::operator=(const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
type = copy_src.type;
memoryObjectId = copy_src.memoryObjectId;
size = copy_src.size;
objectType = copy_src.objectType;
objectHandle = copy_src.objectHandle;
heapIndex = copy_src.heapIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceMemoryReportCallbackDataEXT::~safe_VkDeviceMemoryReportCallbackDataEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceMemoryReportCallbackDataEXT::initialize(const VkDeviceMemoryReportCallbackDataEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
type = in_struct->type;
memoryObjectId = in_struct->memoryObjectId;
size = in_struct->size;
objectType = in_struct->objectType;
objectHandle = in_struct->objectHandle;
heapIndex = in_struct->heapIndex;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceMemoryReportCallbackDataEXT::initialize(const safe_VkDeviceMemoryReportCallbackDataEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
type = copy_src->type;
memoryObjectId = copy_src->memoryObjectId;
size = copy_src->size;
objectType = copy_src->objectType;
objectHandle = copy_src->objectHandle;
heapIndex = copy_src->heapIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
pfnUserCallback(in_struct->pfnUserCallback),
pUserData(in_struct->pUserData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT),
pNext(nullptr),
pUserData(nullptr)
{}
safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pfnUserCallback = copy_src.pfnUserCallback;
pUserData = copy_src.pUserData;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceDeviceMemoryReportCreateInfoEXT& safe_VkDeviceDeviceMemoryReportCreateInfoEXT::operator=(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pfnUserCallback = copy_src.pfnUserCallback;
pUserData = copy_src.pUserData;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceDeviceMemoryReportCreateInfoEXT::~safe_VkDeviceDeviceMemoryReportCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceDeviceMemoryReportCreateInfoEXT::initialize(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pfnUserCallback = in_struct->pfnUserCallback;
pUserData = in_struct->pUserData;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceDeviceMemoryReportCreateInfoEXT::initialize(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pfnUserCallback = copy_src->pfnUserCallback;
pUserData = copy_src->pUserData;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct) :
sType(in_struct->sType),
robustBufferAccess2(in_struct->robustBufferAccess2),
robustImageAccess2(in_struct->robustImageAccess2),
nullDescriptor(in_struct->nullDescriptor)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src)
{
sType = copy_src.sType;
robustBufferAccess2 = copy_src.robustBufferAccess2;
robustImageAccess2 = copy_src.robustImageAccess2;
nullDescriptor = copy_src.nullDescriptor;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceRobustness2FeaturesEXT& safe_VkPhysicalDeviceRobustness2FeaturesEXT::operator=(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
robustBufferAccess2 = copy_src.robustBufferAccess2;
robustImageAccess2 = copy_src.robustImageAccess2;
nullDescriptor = copy_src.nullDescriptor;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceRobustness2FeaturesEXT::~safe_VkPhysicalDeviceRobustness2FeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceRobustness2FeaturesEXT::initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct)
{
sType = in_struct->sType;
robustBufferAccess2 = in_struct->robustBufferAccess2;
robustImageAccess2 = in_struct->robustImageAccess2;
nullDescriptor = in_struct->nullDescriptor;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceRobustness2FeaturesEXT::initialize(const safe_VkPhysicalDeviceRobustness2FeaturesEXT* copy_src)
{
sType = copy_src->sType;
robustBufferAccess2 = copy_src->robustBufferAccess2;
robustImageAccess2 = copy_src->robustImageAccess2;
nullDescriptor = copy_src->nullDescriptor;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct) :
sType(in_struct->sType),
robustStorageBufferAccessSizeAlignment(in_struct->robustStorageBufferAccessSizeAlignment),
robustUniformBufferAccessSizeAlignment(in_struct->robustUniformBufferAccessSizeAlignment)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src)
{
sType = copy_src.sType;
robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceRobustness2PropertiesEXT& safe_VkPhysicalDeviceRobustness2PropertiesEXT::operator=(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceRobustness2PropertiesEXT::~safe_VkPhysicalDeviceRobustness2PropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceRobustness2PropertiesEXT::initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct)
{
sType = in_struct->sType;
robustStorageBufferAccessSizeAlignment = in_struct->robustStorageBufferAccessSizeAlignment;
robustUniformBufferAccessSizeAlignment = in_struct->robustUniformBufferAccessSizeAlignment;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceRobustness2PropertiesEXT::initialize(const safe_VkPhysicalDeviceRobustness2PropertiesEXT* copy_src)
{
sType = copy_src->sType;
robustStorageBufferAccessSizeAlignment = copy_src->robustStorageBufferAccessSizeAlignment;
robustUniformBufferAccessSizeAlignment = copy_src->robustUniformBufferAccessSizeAlignment;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct) :
sType(in_struct->sType),
customBorderColor(in_struct->customBorderColor),
format(in_struct->format)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT(const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
customBorderColor = copy_src.customBorderColor;
format = copy_src.format;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSamplerCustomBorderColorCreateInfoEXT& safe_VkSamplerCustomBorderColorCreateInfoEXT::operator=(const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
customBorderColor = copy_src.customBorderColor;
format = copy_src.format;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSamplerCustomBorderColorCreateInfoEXT::~safe_VkSamplerCustomBorderColorCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSamplerCustomBorderColorCreateInfoEXT::initialize(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
customBorderColor = in_struct->customBorderColor;
format = in_struct->format;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSamplerCustomBorderColorCreateInfoEXT::initialize(const safe_VkSamplerCustomBorderColorCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
customBorderColor = copy_src->customBorderColor;
format = copy_src->format;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct) :
sType(in_struct->sType),
maxCustomBorderColorSamplers(in_struct->maxCustomBorderColorSamplers)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src)
{
sType = copy_src.sType;
maxCustomBorderColorSamplers = copy_src.maxCustomBorderColorSamplers;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::operator=(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxCustomBorderColorSamplers = copy_src.maxCustomBorderColorSamplers;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::~safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::initialize(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct)
{
sType = in_struct->sType;
maxCustomBorderColorSamplers = in_struct->maxCustomBorderColorSamplers;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::initialize(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT* copy_src)
{
sType = copy_src->sType;
maxCustomBorderColorSamplers = copy_src->maxCustomBorderColorSamplers;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct) :
sType(in_struct->sType),
customBorderColors(in_struct->customBorderColors),
customBorderColorWithoutFormat(in_struct->customBorderColorWithoutFormat)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src)
{
sType = copy_src.sType;
customBorderColors = copy_src.customBorderColors;
customBorderColorWithoutFormat = copy_src.customBorderColorWithoutFormat;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::operator=(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
customBorderColors = copy_src.customBorderColors;
customBorderColorWithoutFormat = copy_src.customBorderColorWithoutFormat;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::~safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::initialize(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct)
{
sType = in_struct->sType;
customBorderColors = in_struct->customBorderColors;
customBorderColorWithoutFormat = in_struct->customBorderColorWithoutFormat;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::initialize(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT* copy_src)
{
sType = copy_src->sType;
customBorderColors = copy_src->customBorderColors;
customBorderColorWithoutFormat = copy_src->customBorderColorWithoutFormat;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevicePrivateDataFeaturesEXT::safe_VkPhysicalDevicePrivateDataFeaturesEXT(const VkPhysicalDevicePrivateDataFeaturesEXT* in_struct) :
sType(in_struct->sType),
privateData(in_struct->privateData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePrivateDataFeaturesEXT::safe_VkPhysicalDevicePrivateDataFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDevicePrivateDataFeaturesEXT::safe_VkPhysicalDevicePrivateDataFeaturesEXT(const safe_VkPhysicalDevicePrivateDataFeaturesEXT& copy_src)
{
sType = copy_src.sType;
privateData = copy_src.privateData;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePrivateDataFeaturesEXT& safe_VkPhysicalDevicePrivateDataFeaturesEXT::operator=(const safe_VkPhysicalDevicePrivateDataFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
privateData = copy_src.privateData;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePrivateDataFeaturesEXT::~safe_VkPhysicalDevicePrivateDataFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePrivateDataFeaturesEXT::initialize(const VkPhysicalDevicePrivateDataFeaturesEXT* in_struct)
{
sType = in_struct->sType;
privateData = in_struct->privateData;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePrivateDataFeaturesEXT::initialize(const safe_VkPhysicalDevicePrivateDataFeaturesEXT* copy_src)
{
sType = copy_src->sType;
privateData = copy_src->privateData;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDevicePrivateDataCreateInfoEXT::safe_VkDevicePrivateDataCreateInfoEXT(const VkDevicePrivateDataCreateInfoEXT* in_struct) :
sType(in_struct->sType),
privateDataSlotRequestCount(in_struct->privateDataSlotRequestCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDevicePrivateDataCreateInfoEXT::safe_VkDevicePrivateDataCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkDevicePrivateDataCreateInfoEXT::safe_VkDevicePrivateDataCreateInfoEXT(const safe_VkDevicePrivateDataCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
privateDataSlotRequestCount = copy_src.privateDataSlotRequestCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDevicePrivateDataCreateInfoEXT& safe_VkDevicePrivateDataCreateInfoEXT::operator=(const safe_VkDevicePrivateDataCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
privateDataSlotRequestCount = copy_src.privateDataSlotRequestCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDevicePrivateDataCreateInfoEXT::~safe_VkDevicePrivateDataCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDevicePrivateDataCreateInfoEXT::initialize(const VkDevicePrivateDataCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
privateDataSlotRequestCount = in_struct->privateDataSlotRequestCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDevicePrivateDataCreateInfoEXT::initialize(const safe_VkDevicePrivateDataCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
privateDataSlotRequestCount = copy_src->privateDataSlotRequestCount;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPrivateDataSlotCreateInfoEXT::safe_VkPrivateDataSlotCreateInfoEXT(const VkPrivateDataSlotCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPrivateDataSlotCreateInfoEXT::safe_VkPrivateDataSlotCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT),
pNext(nullptr)
{}
safe_VkPrivateDataSlotCreateInfoEXT::safe_VkPrivateDataSlotCreateInfoEXT(const safe_VkPrivateDataSlotCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPrivateDataSlotCreateInfoEXT& safe_VkPrivateDataSlotCreateInfoEXT::operator=(const safe_VkPrivateDataSlotCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPrivateDataSlotCreateInfoEXT::~safe_VkPrivateDataSlotCreateInfoEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPrivateDataSlotCreateInfoEXT::initialize(const VkPrivateDataSlotCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPrivateDataSlotCreateInfoEXT::initialize(const safe_VkPrivateDataSlotCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* in_struct) :
sType(in_struct->sType),
pipelineCreationCacheControl(in_struct->pipelineCreationCacheControl)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(const safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT& copy_src)
{
sType = copy_src.sType;
pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT& safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::operator=(const safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::~safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::initialize(const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* in_struct)
{
sType = in_struct->sType;
pipelineCreationCacheControl = in_struct->pipelineCreationCacheControl;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::initialize(const safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* copy_src)
{
sType = copy_src->sType;
pipelineCreationCacheControl = copy_src->pipelineCreationCacheControl;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct) :
sType(in_struct->sType),
diagnosticsConfig(in_struct->diagnosticsConfig)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src)
{
sType = copy_src.sType;
diagnosticsConfig = copy_src.diagnosticsConfig;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::operator=(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
diagnosticsConfig = copy_src.diagnosticsConfig;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::~safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::initialize(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct)
{
sType = in_struct->sType;
diagnosticsConfig = in_struct->diagnosticsConfig;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::initialize(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* copy_src)
{
sType = copy_src->sType;
diagnosticsConfig = copy_src->diagnosticsConfig;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV(const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDeviceDiagnosticsConfigCreateInfoNV& safe_VkDeviceDiagnosticsConfigCreateInfoNV::operator=(const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDeviceDiagnosticsConfigCreateInfoNV::~safe_VkDeviceDiagnosticsConfigCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDeviceDiagnosticsConfigCreateInfoNV::initialize(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkDeviceDiagnosticsConfigCreateInfoNV::initialize(const safe_VkDeviceDiagnosticsConfigCreateInfoNV* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct) :
sType(in_struct->sType),
fragmentShadingRateEnums(in_struct->fragmentShadingRateEnums),
supersampleFragmentShadingRates(in_struct->supersampleFragmentShadingRates),
noInvocationFragmentShadingRates(in_struct->noInvocationFragmentShadingRates)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src)
{
sType = copy_src.sType;
fragmentShadingRateEnums = copy_src.fragmentShadingRateEnums;
supersampleFragmentShadingRates = copy_src.supersampleFragmentShadingRates;
noInvocationFragmentShadingRates = copy_src.noInvocationFragmentShadingRates;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::operator=(const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fragmentShadingRateEnums = copy_src.fragmentShadingRateEnums;
supersampleFragmentShadingRates = copy_src.supersampleFragmentShadingRates;
noInvocationFragmentShadingRates = copy_src.noInvocationFragmentShadingRates;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::~safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::initialize(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct)
{
sType = in_struct->sType;
fragmentShadingRateEnums = in_struct->fragmentShadingRateEnums;
supersampleFragmentShadingRates = in_struct->supersampleFragmentShadingRates;
noInvocationFragmentShadingRates = in_struct->noInvocationFragmentShadingRates;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::initialize(const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* copy_src)
{
sType = copy_src->sType;
fragmentShadingRateEnums = copy_src->fragmentShadingRateEnums;
supersampleFragmentShadingRates = copy_src->supersampleFragmentShadingRates;
noInvocationFragmentShadingRates = copy_src->noInvocationFragmentShadingRates;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct) :
sType(in_struct->sType),
maxFragmentShadingRateInvocationCount(in_struct->maxFragmentShadingRateInvocationCount)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src)
{
sType = copy_src.sType;
maxFragmentShadingRateInvocationCount = copy_src.maxFragmentShadingRateInvocationCount;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::operator=(const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxFragmentShadingRateInvocationCount = copy_src.maxFragmentShadingRateInvocationCount;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::~safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::initialize(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct)
{
sType = in_struct->sType;
maxFragmentShadingRateInvocationCount = in_struct->maxFragmentShadingRateInvocationCount;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::initialize(const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* copy_src)
{
sType = copy_src->sType;
maxFragmentShadingRateInvocationCount = copy_src->maxFragmentShadingRateInvocationCount;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct) :
sType(in_struct->sType),
shadingRateType(in_struct->shadingRateType),
shadingRate(in_struct->shadingRate)
{
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = in_struct->combinerOps[i];
}
}
safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV() :
sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV),
pNext(nullptr)
{}
safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src)
{
sType = copy_src.sType;
shadingRateType = copy_src.shadingRateType;
shadingRate = copy_src.shadingRate;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = copy_src.combinerOps[i];
}
}
safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::operator=(const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shadingRateType = copy_src.shadingRateType;
shadingRate = copy_src.shadingRate;
pNext = SafePnextCopy(copy_src.pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = copy_src.combinerOps[i];
}
return *this;
}
safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::~safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::initialize(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct)
{
sType = in_struct->sType;
shadingRateType = in_struct->shadingRateType;
shadingRate = in_struct->shadingRate;
pNext = SafePnextCopy(in_struct->pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = in_struct->combinerOps[i];
}
}
void safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::initialize(const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* copy_src)
{
sType = copy_src->sType;
shadingRateType = copy_src->shadingRateType;
shadingRate = copy_src->shadingRate;
pNext = SafePnextCopy(copy_src->pNext);
for (uint32_t i = 0; i < 2; ++i) {
combinerOps[i] = copy_src->combinerOps[i];
}
}
safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct) :
sType(in_struct->sType),
ycbcr2plane444Formats(in_struct->ycbcr2plane444Formats)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src)
{
sType = copy_src.sType;
ycbcr2plane444Formats = copy_src.ycbcr2plane444Formats;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::operator=(const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
ycbcr2plane444Formats = copy_src.ycbcr2plane444Formats;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::~safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::initialize(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct)
{
sType = in_struct->sType;
ycbcr2plane444Formats = in_struct->ycbcr2plane444Formats;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::initialize(const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* copy_src)
{
sType = copy_src->sType;
ycbcr2plane444Formats = copy_src->ycbcr2plane444Formats;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct) :
sType(in_struct->sType),
fragmentDensityMapDeferred(in_struct->fragmentDensityMapDeferred)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src)
{
sType = copy_src.sType;
fragmentDensityMapDeferred = copy_src.fragmentDensityMapDeferred;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::operator=(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
fragmentDensityMapDeferred = copy_src.fragmentDensityMapDeferred;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::~safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::initialize(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct)
{
sType = in_struct->sType;
fragmentDensityMapDeferred = in_struct->fragmentDensityMapDeferred;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::initialize(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* copy_src)
{
sType = copy_src->sType;
fragmentDensityMapDeferred = copy_src->fragmentDensityMapDeferred;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct) :
sType(in_struct->sType),
subsampledLoads(in_struct->subsampledLoads),
subsampledCoarseReconstructionEarlyAccess(in_struct->subsampledCoarseReconstructionEarlyAccess),
maxSubsampledArrayLayers(in_struct->maxSubsampledArrayLayers),
maxDescriptorSetSubsampledSamplers(in_struct->maxDescriptorSetSubsampledSamplers)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src)
{
sType = copy_src.sType;
subsampledLoads = copy_src.subsampledLoads;
subsampledCoarseReconstructionEarlyAccess = copy_src.subsampledCoarseReconstructionEarlyAccess;
maxSubsampledArrayLayers = copy_src.maxSubsampledArrayLayers;
maxDescriptorSetSubsampledSamplers = copy_src.maxDescriptorSetSubsampledSamplers;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::operator=(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
subsampledLoads = copy_src.subsampledLoads;
subsampledCoarseReconstructionEarlyAccess = copy_src.subsampledCoarseReconstructionEarlyAccess;
maxSubsampledArrayLayers = copy_src.maxSubsampledArrayLayers;
maxDescriptorSetSubsampledSamplers = copy_src.maxDescriptorSetSubsampledSamplers;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::~safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::initialize(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct)
{
sType = in_struct->sType;
subsampledLoads = in_struct->subsampledLoads;
subsampledCoarseReconstructionEarlyAccess = in_struct->subsampledCoarseReconstructionEarlyAccess;
maxSubsampledArrayLayers = in_struct->maxSubsampledArrayLayers;
maxDescriptorSetSubsampledSamplers = in_struct->maxDescriptorSetSubsampledSamplers;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::initialize(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* copy_src)
{
sType = copy_src->sType;
subsampledLoads = copy_src->subsampledLoads;
subsampledCoarseReconstructionEarlyAccess = copy_src->subsampledCoarseReconstructionEarlyAccess;
maxSubsampledArrayLayers = copy_src->maxSubsampledArrayLayers;
maxDescriptorSetSubsampledSamplers = copy_src->maxDescriptorSetSubsampledSamplers;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM* in_struct) :
sType(in_struct->sType),
transform(in_struct->transform)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM() :
sType(VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM),
pNext(nullptr)
{}
safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM(const safe_VkCopyCommandTransformInfoQCOM& copy_src)
{
sType = copy_src.sType;
transform = copy_src.transform;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCopyCommandTransformInfoQCOM& safe_VkCopyCommandTransformInfoQCOM::operator=(const safe_VkCopyCommandTransformInfoQCOM& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
transform = copy_src.transform;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCopyCommandTransformInfoQCOM::~safe_VkCopyCommandTransformInfoQCOM()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyCommandTransformInfoQCOM::initialize(const VkCopyCommandTransformInfoQCOM* in_struct)
{
sType = in_struct->sType;
transform = in_struct->transform;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCopyCommandTransformInfoQCOM::initialize(const safe_VkCopyCommandTransformInfoQCOM* copy_src)
{
sType = copy_src->sType;
transform = copy_src->transform;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceImageRobustnessFeaturesEXT::safe_VkPhysicalDeviceImageRobustnessFeaturesEXT(const VkPhysicalDeviceImageRobustnessFeaturesEXT* in_struct) :
sType(in_struct->sType),
robustImageAccess(in_struct->robustImageAccess)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceImageRobustnessFeaturesEXT::safe_VkPhysicalDeviceImageRobustnessFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceImageRobustnessFeaturesEXT::safe_VkPhysicalDeviceImageRobustnessFeaturesEXT(const safe_VkPhysicalDeviceImageRobustnessFeaturesEXT& copy_src)
{
sType = copy_src.sType;
robustImageAccess = copy_src.robustImageAccess;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceImageRobustnessFeaturesEXT& safe_VkPhysicalDeviceImageRobustnessFeaturesEXT::operator=(const safe_VkPhysicalDeviceImageRobustnessFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
robustImageAccess = copy_src.robustImageAccess;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceImageRobustnessFeaturesEXT::~safe_VkPhysicalDeviceImageRobustnessFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceImageRobustnessFeaturesEXT::initialize(const VkPhysicalDeviceImageRobustnessFeaturesEXT* in_struct)
{
sType = in_struct->sType;
robustImageAccess = in_struct->robustImageAccess;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceImageRobustnessFeaturesEXT::initialize(const safe_VkPhysicalDeviceImageRobustnessFeaturesEXT* copy_src)
{
sType = copy_src->sType;
robustImageAccess = copy_src->robustImageAccess;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct) :
sType(in_struct->sType),
formatA4R4G4B4(in_struct->formatA4R4G4B4),
formatA4B4G4R4(in_struct->formatA4B4G4R4)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT(const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src)
{
sType = copy_src.sType;
formatA4R4G4B4 = copy_src.formatA4R4G4B4;
formatA4B4G4R4 = copy_src.formatA4B4G4R4;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDevice4444FormatsFeaturesEXT& safe_VkPhysicalDevice4444FormatsFeaturesEXT::operator=(const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
formatA4R4G4B4 = copy_src.formatA4R4G4B4;
formatA4B4G4R4 = copy_src.formatA4B4G4R4;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDevice4444FormatsFeaturesEXT::~safe_VkPhysicalDevice4444FormatsFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDevice4444FormatsFeaturesEXT::initialize(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct)
{
sType = in_struct->sType;
formatA4R4G4B4 = in_struct->formatA4R4G4B4;
formatA4B4G4R4 = in_struct->formatA4B4G4R4;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDevice4444FormatsFeaturesEXT::initialize(const safe_VkPhysicalDevice4444FormatsFeaturesEXT* copy_src)
{
sType = copy_src->sType;
formatA4R4G4B4 = copy_src->formatA4R4G4B4;
formatA4B4G4R4 = copy_src->formatA4B4G4R4;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
dfb(nullptr),
surface(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->dfb) {
dfb = new IDirectFB(*in_struct->dfb);
}
if (in_struct->surface) {
surface = new IDirectFBSurface(*in_struct->surface);
}
}
safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT),
pNext(nullptr),
dfb(nullptr),
surface(nullptr)
{}
safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
dfb = nullptr;
surface = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.dfb) {
dfb = new IDirectFB(*copy_src.dfb);
}
if (copy_src.surface) {
surface = new IDirectFBSurface(*copy_src.surface);
}
}
safe_VkDirectFBSurfaceCreateInfoEXT& safe_VkDirectFBSurfaceCreateInfoEXT::operator=(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (dfb)
delete dfb;
if (surface)
delete surface;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
dfb = nullptr;
surface = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.dfb) {
dfb = new IDirectFB(*copy_src.dfb);
}
if (copy_src.surface) {
surface = new IDirectFBSurface(*copy_src.surface);
}
return *this;
}
safe_VkDirectFBSurfaceCreateInfoEXT::~safe_VkDirectFBSurfaceCreateInfoEXT()
{
if (dfb)
delete dfb;
if (surface)
delete surface;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkDirectFBSurfaceCreateInfoEXT::initialize(const VkDirectFBSurfaceCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
dfb = nullptr;
surface = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->dfb) {
dfb = new IDirectFB(*in_struct->dfb);
}
if (in_struct->surface) {
surface = new IDirectFBSurface(*in_struct->surface);
}
}
void safe_VkDirectFBSurfaceCreateInfoEXT::initialize(const safe_VkDirectFBSurfaceCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
dfb = nullptr;
surface = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->dfb) {
dfb = new IDirectFB(*copy_src->dfb);
}
if (copy_src->surface) {
surface = new IDirectFBSurface(*copy_src->surface);
}
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* in_struct) :
sType(in_struct->sType),
mutableDescriptorType(in_struct->mutableDescriptorType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE),
pNext(nullptr)
{}
safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& copy_src)
{
sType = copy_src.sType;
mutableDescriptorType = copy_src.mutableDescriptorType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::operator=(const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
mutableDescriptorType = copy_src.mutableDescriptorType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::~safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::initialize(const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* in_struct)
{
sType = in_struct->sType;
mutableDescriptorType = in_struct->mutableDescriptorType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::initialize(const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* copy_src)
{
sType = copy_src->sType;
mutableDescriptorType = copy_src->mutableDescriptorType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkMutableDescriptorTypeListVALVE::safe_VkMutableDescriptorTypeListVALVE(const VkMutableDescriptorTypeListVALVE* in_struct) :
descriptorTypeCount(in_struct->descriptorTypeCount),
pDescriptorTypes(nullptr)
{
if (in_struct->pDescriptorTypes) {
pDescriptorTypes = new VkDescriptorType[in_struct->descriptorTypeCount];
memcpy ((void *)pDescriptorTypes, (void *)in_struct->pDescriptorTypes, sizeof(VkDescriptorType)*in_struct->descriptorTypeCount);
}
}
safe_VkMutableDescriptorTypeListVALVE::safe_VkMutableDescriptorTypeListVALVE() :
pDescriptorTypes(nullptr)
{}
safe_VkMutableDescriptorTypeListVALVE::safe_VkMutableDescriptorTypeListVALVE(const safe_VkMutableDescriptorTypeListVALVE& copy_src)
{
descriptorTypeCount = copy_src.descriptorTypeCount;
pDescriptorTypes = nullptr;
if (copy_src.pDescriptorTypes) {
pDescriptorTypes = new VkDescriptorType[copy_src.descriptorTypeCount];
memcpy ((void *)pDescriptorTypes, (void *)copy_src.pDescriptorTypes, sizeof(VkDescriptorType)*copy_src.descriptorTypeCount);
}
}
safe_VkMutableDescriptorTypeListVALVE& safe_VkMutableDescriptorTypeListVALVE::operator=(const safe_VkMutableDescriptorTypeListVALVE& copy_src)
{
if (&copy_src == this) return *this;
if (pDescriptorTypes)
delete[] pDescriptorTypes;
descriptorTypeCount = copy_src.descriptorTypeCount;
pDescriptorTypes = nullptr;
if (copy_src.pDescriptorTypes) {
pDescriptorTypes = new VkDescriptorType[copy_src.descriptorTypeCount];
memcpy ((void *)pDescriptorTypes, (void *)copy_src.pDescriptorTypes, sizeof(VkDescriptorType)*copy_src.descriptorTypeCount);
}
return *this;
}
safe_VkMutableDescriptorTypeListVALVE::~safe_VkMutableDescriptorTypeListVALVE()
{
if (pDescriptorTypes)
delete[] pDescriptorTypes;
}
void safe_VkMutableDescriptorTypeListVALVE::initialize(const VkMutableDescriptorTypeListVALVE* in_struct)
{
descriptorTypeCount = in_struct->descriptorTypeCount;
pDescriptorTypes = nullptr;
if (in_struct->pDescriptorTypes) {
pDescriptorTypes = new VkDescriptorType[in_struct->descriptorTypeCount];
memcpy ((void *)pDescriptorTypes, (void *)in_struct->pDescriptorTypes, sizeof(VkDescriptorType)*in_struct->descriptorTypeCount);
}
}
void safe_VkMutableDescriptorTypeListVALVE::initialize(const safe_VkMutableDescriptorTypeListVALVE* copy_src)
{
descriptorTypeCount = copy_src->descriptorTypeCount;
pDescriptorTypes = nullptr;
if (copy_src->pDescriptorTypes) {
pDescriptorTypes = new VkDescriptorType[copy_src->descriptorTypeCount];
memcpy ((void *)pDescriptorTypes, (void *)copy_src->pDescriptorTypes, sizeof(VkDescriptorType)*copy_src->descriptorTypeCount);
}
}
safe_VkMutableDescriptorTypeCreateInfoVALVE::safe_VkMutableDescriptorTypeCreateInfoVALVE(const VkMutableDescriptorTypeCreateInfoVALVE* in_struct) :
sType(in_struct->sType),
mutableDescriptorTypeListCount(in_struct->mutableDescriptorTypeListCount),
pMutableDescriptorTypeLists(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (mutableDescriptorTypeListCount && in_struct->pMutableDescriptorTypeLists) {
pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListVALVE[mutableDescriptorTypeListCount];
for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
pMutableDescriptorTypeLists[i].initialize(&in_struct->pMutableDescriptorTypeLists[i]);
}
}
}
safe_VkMutableDescriptorTypeCreateInfoVALVE::safe_VkMutableDescriptorTypeCreateInfoVALVE() :
sType(VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE),
pNext(nullptr),
pMutableDescriptorTypeLists(nullptr)
{}
safe_VkMutableDescriptorTypeCreateInfoVALVE::safe_VkMutableDescriptorTypeCreateInfoVALVE(const safe_VkMutableDescriptorTypeCreateInfoVALVE& copy_src)
{
sType = copy_src.sType;
mutableDescriptorTypeListCount = copy_src.mutableDescriptorTypeListCount;
pMutableDescriptorTypeLists = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (mutableDescriptorTypeListCount && copy_src.pMutableDescriptorTypeLists) {
pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListVALVE[mutableDescriptorTypeListCount];
for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
pMutableDescriptorTypeLists[i].initialize(&copy_src.pMutableDescriptorTypeLists[i]);
}
}
}
safe_VkMutableDescriptorTypeCreateInfoVALVE& safe_VkMutableDescriptorTypeCreateInfoVALVE::operator=(const safe_VkMutableDescriptorTypeCreateInfoVALVE& copy_src)
{
if (&copy_src == this) return *this;
if (pMutableDescriptorTypeLists)
delete[] pMutableDescriptorTypeLists;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
mutableDescriptorTypeListCount = copy_src.mutableDescriptorTypeListCount;
pMutableDescriptorTypeLists = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (mutableDescriptorTypeListCount && copy_src.pMutableDescriptorTypeLists) {
pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListVALVE[mutableDescriptorTypeListCount];
for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
pMutableDescriptorTypeLists[i].initialize(&copy_src.pMutableDescriptorTypeLists[i]);
}
}
return *this;
}
safe_VkMutableDescriptorTypeCreateInfoVALVE::~safe_VkMutableDescriptorTypeCreateInfoVALVE()
{
if (pMutableDescriptorTypeLists)
delete[] pMutableDescriptorTypeLists;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMutableDescriptorTypeCreateInfoVALVE::initialize(const VkMutableDescriptorTypeCreateInfoVALVE* in_struct)
{
sType = in_struct->sType;
mutableDescriptorTypeListCount = in_struct->mutableDescriptorTypeListCount;
pMutableDescriptorTypeLists = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (mutableDescriptorTypeListCount && in_struct->pMutableDescriptorTypeLists) {
pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListVALVE[mutableDescriptorTypeListCount];
for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
pMutableDescriptorTypeLists[i].initialize(&in_struct->pMutableDescriptorTypeLists[i]);
}
}
}
void safe_VkMutableDescriptorTypeCreateInfoVALVE::initialize(const safe_VkMutableDescriptorTypeCreateInfoVALVE* copy_src)
{
sType = copy_src->sType;
mutableDescriptorTypeListCount = copy_src->mutableDescriptorTypeListCount;
pMutableDescriptorTypeLists = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (mutableDescriptorTypeListCount && copy_src->pMutableDescriptorTypeLists) {
pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListVALVE[mutableDescriptorTypeListCount];
for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
pMutableDescriptorTypeLists[i].initialize(&copy_src->pMutableDescriptorTypeLists[i]);
}
}
}
safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct) :
sType(in_struct->sType),
vertexInputDynamicState(in_struct->vertexInputDynamicState)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src)
{
sType = copy_src.sType;
vertexInputDynamicState = copy_src.vertexInputDynamicState;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::operator=(const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
vertexInputDynamicState = copy_src.vertexInputDynamicState;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::~safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::initialize(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct)
{
sType = in_struct->sType;
vertexInputDynamicState = in_struct->vertexInputDynamicState;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::initialize(const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* copy_src)
{
sType = copy_src->sType;
vertexInputDynamicState = copy_src->vertexInputDynamicState;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT* in_struct) :
sType(in_struct->sType),
binding(in_struct->binding),
stride(in_struct->stride),
inputRate(in_struct->inputRate),
divisor(in_struct->divisor)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT() :
sType(VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT),
pNext(nullptr)
{}
safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT(const safe_VkVertexInputBindingDescription2EXT& copy_src)
{
sType = copy_src.sType;
binding = copy_src.binding;
stride = copy_src.stride;
inputRate = copy_src.inputRate;
divisor = copy_src.divisor;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVertexInputBindingDescription2EXT& safe_VkVertexInputBindingDescription2EXT::operator=(const safe_VkVertexInputBindingDescription2EXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
binding = copy_src.binding;
stride = copy_src.stride;
inputRate = copy_src.inputRate;
divisor = copy_src.divisor;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVertexInputBindingDescription2EXT::~safe_VkVertexInputBindingDescription2EXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVertexInputBindingDescription2EXT::initialize(const VkVertexInputBindingDescription2EXT* in_struct)
{
sType = in_struct->sType;
binding = in_struct->binding;
stride = in_struct->stride;
inputRate = in_struct->inputRate;
divisor = in_struct->divisor;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVertexInputBindingDescription2EXT::initialize(const safe_VkVertexInputBindingDescription2EXT* copy_src)
{
sType = copy_src->sType;
binding = copy_src->binding;
stride = copy_src->stride;
inputRate = copy_src->inputRate;
divisor = copy_src->divisor;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT* in_struct) :
sType(in_struct->sType),
location(in_struct->location),
binding(in_struct->binding),
format(in_struct->format),
offset(in_struct->offset)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT() :
sType(VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT),
pNext(nullptr)
{}
safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT(const safe_VkVertexInputAttributeDescription2EXT& copy_src)
{
sType = copy_src.sType;
location = copy_src.location;
binding = copy_src.binding;
format = copy_src.format;
offset = copy_src.offset;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkVertexInputAttributeDescription2EXT& safe_VkVertexInputAttributeDescription2EXT::operator=(const safe_VkVertexInputAttributeDescription2EXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
location = copy_src.location;
binding = copy_src.binding;
format = copy_src.format;
offset = copy_src.offset;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkVertexInputAttributeDescription2EXT::~safe_VkVertexInputAttributeDescription2EXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkVertexInputAttributeDescription2EXT::initialize(const VkVertexInputAttributeDescription2EXT* in_struct)
{
sType = in_struct->sType;
location = in_struct->location;
binding = in_struct->binding;
format = in_struct->format;
offset = in_struct->offset;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkVertexInputAttributeDescription2EXT::initialize(const safe_VkVertexInputAttributeDescription2EXT* copy_src)
{
sType = copy_src->sType;
location = copy_src->location;
binding = copy_src->binding;
format = copy_src->format;
offset = copy_src->offset;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_FUCHSIA
safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct) :
sType(in_struct->sType),
handleType(in_struct->handleType),
handle(in_struct->handle)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA() :
sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA),
pNext(nullptr)
{}
safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src)
{
sType = copy_src.sType;
handleType = copy_src.handleType;
handle = copy_src.handle;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportMemoryZirconHandleInfoFUCHSIA& safe_VkImportMemoryZirconHandleInfoFUCHSIA::operator=(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
handleType = copy_src.handleType;
handle = copy_src.handle;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportMemoryZirconHandleInfoFUCHSIA::~safe_VkImportMemoryZirconHandleInfoFUCHSIA()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportMemoryZirconHandleInfoFUCHSIA::initialize(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct)
{
sType = in_struct->sType;
handleType = in_struct->handleType;
handle = in_struct->handle;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportMemoryZirconHandleInfoFUCHSIA::initialize(const safe_VkImportMemoryZirconHandleInfoFUCHSIA* copy_src)
{
sType = copy_src->sType;
handleType = copy_src->handleType;
handle = copy_src->handle;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_FUCHSIA
safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct) :
sType(in_struct->sType),
memoryTypeBits(in_struct->memoryTypeBits)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA() :
sType(VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA),
pNext(nullptr)
{}
safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src)
{
sType = copy_src.sType;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryZirconHandlePropertiesFUCHSIA& safe_VkMemoryZirconHandlePropertiesFUCHSIA::operator=(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memoryTypeBits = copy_src.memoryTypeBits;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryZirconHandlePropertiesFUCHSIA::~safe_VkMemoryZirconHandlePropertiesFUCHSIA()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryZirconHandlePropertiesFUCHSIA::initialize(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct)
{
sType = in_struct->sType;
memoryTypeBits = in_struct->memoryTypeBits;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryZirconHandlePropertiesFUCHSIA::initialize(const safe_VkMemoryZirconHandlePropertiesFUCHSIA* copy_src)
{
sType = copy_src->sType;
memoryTypeBits = copy_src->memoryTypeBits;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_FUCHSIA
safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct) :
sType(in_struct->sType),
memory(in_struct->memory),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA() :
sType(VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA),
pNext(nullptr)
{}
safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src)
{
sType = copy_src.sType;
memory = copy_src.memory;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkMemoryGetZirconHandleInfoFUCHSIA& safe_VkMemoryGetZirconHandleInfoFUCHSIA::operator=(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
memory = copy_src.memory;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkMemoryGetZirconHandleInfoFUCHSIA::~safe_VkMemoryGetZirconHandleInfoFUCHSIA()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkMemoryGetZirconHandleInfoFUCHSIA::initialize(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct)
{
sType = in_struct->sType;
memory = in_struct->memory;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkMemoryGetZirconHandleInfoFUCHSIA::initialize(const safe_VkMemoryGetZirconHandleInfoFUCHSIA* copy_src)
{
sType = copy_src->sType;
memory = copy_src->memory;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_FUCHSIA
safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct) :
sType(in_struct->sType),
semaphore(in_struct->semaphore),
flags(in_struct->flags),
handleType(in_struct->handleType),
zirconHandle(in_struct->zirconHandle)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA() :
sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA),
pNext(nullptr)
{}
safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src)
{
sType = copy_src.sType;
semaphore = copy_src.semaphore;
flags = copy_src.flags;
handleType = copy_src.handleType;
zirconHandle = copy_src.zirconHandle;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::operator=(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphore = copy_src.semaphore;
flags = copy_src.flags;
handleType = copy_src.handleType;
zirconHandle = copy_src.zirconHandle;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::~safe_VkImportSemaphoreZirconHandleInfoFUCHSIA()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct)
{
sType = in_struct->sType;
semaphore = in_struct->semaphore;
flags = in_struct->flags;
handleType = in_struct->handleType;
zirconHandle = in_struct->zirconHandle;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA* copy_src)
{
sType = copy_src->sType;
semaphore = copy_src->semaphore;
flags = copy_src->flags;
handleType = copy_src->handleType;
zirconHandle = copy_src->zirconHandle;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_FUCHSIA
safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct) :
sType(in_struct->sType),
semaphore(in_struct->semaphore),
handleType(in_struct->handleType)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA() :
sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA),
pNext(nullptr)
{}
safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src)
{
sType = copy_src.sType;
semaphore = copy_src.semaphore;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::operator=(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
semaphore = copy_src.semaphore;
handleType = copy_src.handleType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::~safe_VkSemaphoreGetZirconHandleInfoFUCHSIA()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::initialize(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct)
{
sType = in_struct->sType;
semaphore = in_struct->semaphore;
handleType = in_struct->handleType;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::initialize(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA* copy_src)
{
sType = copy_src->sType;
semaphore = copy_src->semaphore;
handleType = copy_src->handleType;
pNext = SafePnextCopy(copy_src->pNext);
}
#endif // VK_USE_PLATFORM_FUCHSIA
safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct) :
sType(in_struct->sType),
extendedDynamicState2(in_struct->extendedDynamicState2),
extendedDynamicState2LogicOp(in_struct->extendedDynamicState2LogicOp),
extendedDynamicState2PatchControlPoints(in_struct->extendedDynamicState2PatchControlPoints)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src)
{
sType = copy_src.sType;
extendedDynamicState2 = copy_src.extendedDynamicState2;
extendedDynamicState2LogicOp = copy_src.extendedDynamicState2LogicOp;
extendedDynamicState2PatchControlPoints = copy_src.extendedDynamicState2PatchControlPoints;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::operator=(const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
extendedDynamicState2 = copy_src.extendedDynamicState2;
extendedDynamicState2LogicOp = copy_src.extendedDynamicState2LogicOp;
extendedDynamicState2PatchControlPoints = copy_src.extendedDynamicState2PatchControlPoints;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::initialize(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct)
{
sType = in_struct->sType;
extendedDynamicState2 = in_struct->extendedDynamicState2;
extendedDynamicState2LogicOp = in_struct->extendedDynamicState2LogicOp;
extendedDynamicState2PatchControlPoints = in_struct->extendedDynamicState2PatchControlPoints;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::initialize(const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* copy_src)
{
sType = copy_src->sType;
extendedDynamicState2 = copy_src->extendedDynamicState2;
extendedDynamicState2LogicOp = copy_src->extendedDynamicState2LogicOp;
extendedDynamicState2PatchControlPoints = copy_src->extendedDynamicState2PatchControlPoints;
pNext = SafePnextCopy(copy_src->pNext);
}
#ifdef VK_USE_PLATFORM_SCREEN_QNX
safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
context(nullptr),
window(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->context) {
context = new _screen_context(*in_struct->context);
}
if (in_struct->window) {
window = new _screen_window(*in_struct->window);
}
}
safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX() :
sType(VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX),
pNext(nullptr),
context(nullptr),
window(nullptr)
{}
safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX(const safe_VkScreenSurfaceCreateInfoQNX& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
context = nullptr;
window = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.context) {
context = new _screen_context(*copy_src.context);
}
if (copy_src.window) {
window = new _screen_window(*copy_src.window);
}
}
safe_VkScreenSurfaceCreateInfoQNX& safe_VkScreenSurfaceCreateInfoQNX::operator=(const safe_VkScreenSurfaceCreateInfoQNX& copy_src)
{
if (&copy_src == this) return *this;
if (context)
delete context;
if (window)
delete window;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
context = nullptr;
window = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.context) {
context = new _screen_context(*copy_src.context);
}
if (copy_src.window) {
window = new _screen_window(*copy_src.window);
}
return *this;
}
safe_VkScreenSurfaceCreateInfoQNX::~safe_VkScreenSurfaceCreateInfoQNX()
{
if (context)
delete context;
if (window)
delete window;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkScreenSurfaceCreateInfoQNX::initialize(const VkScreenSurfaceCreateInfoQNX* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
context = nullptr;
window = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->context) {
context = new _screen_context(*in_struct->context);
}
if (in_struct->window) {
window = new _screen_window(*in_struct->window);
}
}
void safe_VkScreenSurfaceCreateInfoQNX::initialize(const safe_VkScreenSurfaceCreateInfoQNX* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
context = nullptr;
window = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->context) {
context = new _screen_context(*copy_src->context);
}
if (copy_src->window) {
window = new _screen_window(*copy_src->window);
}
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct) :
sType(in_struct->sType),
colorWriteEnable(in_struct->colorWriteEnable)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT),
pNext(nullptr)
{}
safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src)
{
sType = copy_src.sType;
colorWriteEnable = copy_src.colorWriteEnable;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::operator=(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
colorWriteEnable = copy_src.colorWriteEnable;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::~safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::initialize(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct)
{
sType = in_struct->sType;
colorWriteEnable = in_struct->colorWriteEnable;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::initialize(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT* copy_src)
{
sType = copy_src->sType;
colorWriteEnable = copy_src->colorWriteEnable;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT* in_struct) :
sType(in_struct->sType),
attachmentCount(in_struct->attachmentCount),
pColorWriteEnables(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pColorWriteEnables) {
pColorWriteEnables = new VkBool32[in_struct->attachmentCount];
memcpy ((void *)pColorWriteEnables, (void *)in_struct->pColorWriteEnables, sizeof(VkBool32)*in_struct->attachmentCount);
}
}
safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT() :
sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT),
pNext(nullptr),
pColorWriteEnables(nullptr)
{}
safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT(const safe_VkPipelineColorWriteCreateInfoEXT& copy_src)
{
sType = copy_src.sType;
attachmentCount = copy_src.attachmentCount;
pColorWriteEnables = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pColorWriteEnables) {
pColorWriteEnables = new VkBool32[copy_src.attachmentCount];
memcpy ((void *)pColorWriteEnables, (void *)copy_src.pColorWriteEnables, sizeof(VkBool32)*copy_src.attachmentCount);
}
}
safe_VkPipelineColorWriteCreateInfoEXT& safe_VkPipelineColorWriteCreateInfoEXT::operator=(const safe_VkPipelineColorWriteCreateInfoEXT& copy_src)
{
if (&copy_src == this) return *this;
if (pColorWriteEnables)
delete[] pColorWriteEnables;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
attachmentCount = copy_src.attachmentCount;
pColorWriteEnables = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pColorWriteEnables) {
pColorWriteEnables = new VkBool32[copy_src.attachmentCount];
memcpy ((void *)pColorWriteEnables, (void *)copy_src.pColorWriteEnables, sizeof(VkBool32)*copy_src.attachmentCount);
}
return *this;
}
safe_VkPipelineColorWriteCreateInfoEXT::~safe_VkPipelineColorWriteCreateInfoEXT()
{
if (pColorWriteEnables)
delete[] pColorWriteEnables;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPipelineColorWriteCreateInfoEXT::initialize(const VkPipelineColorWriteCreateInfoEXT* in_struct)
{
sType = in_struct->sType;
attachmentCount = in_struct->attachmentCount;
pColorWriteEnables = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pColorWriteEnables) {
pColorWriteEnables = new VkBool32[in_struct->attachmentCount];
memcpy ((void *)pColorWriteEnables, (void *)in_struct->pColorWriteEnables, sizeof(VkBool32)*in_struct->attachmentCount);
}
}
void safe_VkPipelineColorWriteCreateInfoEXT::initialize(const safe_VkPipelineColorWriteCreateInfoEXT* copy_src)
{
sType = copy_src->sType;
attachmentCount = copy_src->attachmentCount;
pColorWriteEnables = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pColorWriteEnables) {
pColorWriteEnables = new VkBool32[copy_src->attachmentCount];
memcpy ((void *)pColorWriteEnables, (void *)copy_src->pColorWriteEnables, sizeof(VkBool32)*copy_src->attachmentCount);
}
}
safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct)
{
initialize(in_struct);
}
safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR() :
hostAddress(nullptr)
{}
safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR(const safe_VkDeviceOrHostAddressKHR& copy_src)
{
deviceAddress = copy_src.deviceAddress;
hostAddress = copy_src.hostAddress;
}
safe_VkDeviceOrHostAddressKHR& safe_VkDeviceOrHostAddressKHR::operator=(const safe_VkDeviceOrHostAddressKHR& copy_src)
{
if (&copy_src == this) return *this;
deviceAddress = copy_src.deviceAddress;
hostAddress = copy_src.hostAddress;
return *this;
}
safe_VkDeviceOrHostAddressKHR::~safe_VkDeviceOrHostAddressKHR()
{
}
void safe_VkDeviceOrHostAddressKHR::initialize(const VkDeviceOrHostAddressKHR* in_struct)
{
deviceAddress = in_struct->deviceAddress;
hostAddress = in_struct->hostAddress;
}
void safe_VkDeviceOrHostAddressKHR::initialize(const safe_VkDeviceOrHostAddressKHR* copy_src)
{
deviceAddress = copy_src->deviceAddress;
hostAddress = copy_src->hostAddress;
}
safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct)
{
initialize(in_struct);
}
safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR() :
hostAddress(nullptr)
{}
safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const safe_VkDeviceOrHostAddressConstKHR& copy_src)
{
deviceAddress = copy_src.deviceAddress;
hostAddress = copy_src.hostAddress;
}
safe_VkDeviceOrHostAddressConstKHR& safe_VkDeviceOrHostAddressConstKHR::operator=(const safe_VkDeviceOrHostAddressConstKHR& copy_src)
{
if (&copy_src == this) return *this;
deviceAddress = copy_src.deviceAddress;
hostAddress = copy_src.hostAddress;
return *this;
}
safe_VkDeviceOrHostAddressConstKHR::~safe_VkDeviceOrHostAddressConstKHR()
{
}
void safe_VkDeviceOrHostAddressConstKHR::initialize(const VkDeviceOrHostAddressConstKHR* in_struct)
{
deviceAddress = in_struct->deviceAddress;
hostAddress = in_struct->hostAddress;
}
void safe_VkDeviceOrHostAddressConstKHR::initialize(const safe_VkDeviceOrHostAddressConstKHR* copy_src)
{
deviceAddress = copy_src->deviceAddress;
hostAddress = copy_src->hostAddress;
}
safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct) :
sType(in_struct->sType),
vertexFormat(in_struct->vertexFormat),
vertexData(&in_struct->vertexData),
vertexStride(in_struct->vertexStride),
maxVertex(in_struct->maxVertex),
indexType(in_struct->indexType),
indexData(&in_struct->indexData),
transformData(&in_struct->transformData)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR),
pNext(nullptr)
{}
safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src)
{
sType = copy_src.sType;
vertexFormat = copy_src.vertexFormat;
vertexData.initialize(&copy_src.vertexData);
vertexStride = copy_src.vertexStride;
maxVertex = copy_src.maxVertex;
indexType = copy_src.indexType;
indexData.initialize(&copy_src.indexData);
transformData.initialize(&copy_src.transformData);
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureGeometryTrianglesDataKHR& safe_VkAccelerationStructureGeometryTrianglesDataKHR::operator=(const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
vertexFormat = copy_src.vertexFormat;
vertexData.initialize(&copy_src.vertexData);
vertexStride = copy_src.vertexStride;
maxVertex = copy_src.maxVertex;
indexType = copy_src.indexType;
indexData.initialize(&copy_src.indexData);
transformData.initialize(&copy_src.transformData);
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureGeometryTrianglesDataKHR::~safe_VkAccelerationStructureGeometryTrianglesDataKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureGeometryTrianglesDataKHR::initialize(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct)
{
sType = in_struct->sType;
vertexFormat = in_struct->vertexFormat;
vertexData.initialize(&in_struct->vertexData);
vertexStride = in_struct->vertexStride;
maxVertex = in_struct->maxVertex;
indexType = in_struct->indexType;
indexData.initialize(&in_struct->indexData);
transformData.initialize(&in_struct->transformData);
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureGeometryTrianglesDataKHR::initialize(const safe_VkAccelerationStructureGeometryTrianglesDataKHR* copy_src)
{
sType = copy_src->sType;
vertexFormat = copy_src->vertexFormat;
vertexData.initialize(&copy_src->vertexData);
vertexStride = copy_src->vertexStride;
maxVertex = copy_src->maxVertex;
indexType = copy_src->indexType;
indexData.initialize(&copy_src->indexData);
transformData.initialize(&copy_src->transformData);
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct) :
sType(in_struct->sType),
data(&in_struct->data),
stride(in_struct->stride)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR),
pNext(nullptr)
{}
safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src)
{
sType = copy_src.sType;
data.initialize(&copy_src.data);
stride = copy_src.stride;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureGeometryAabbsDataKHR& safe_VkAccelerationStructureGeometryAabbsDataKHR::operator=(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
data.initialize(&copy_src.data);
stride = copy_src.stride;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureGeometryAabbsDataKHR::~safe_VkAccelerationStructureGeometryAabbsDataKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureGeometryAabbsDataKHR::initialize(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct)
{
sType = in_struct->sType;
data.initialize(&in_struct->data);
stride = in_struct->stride;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureGeometryAabbsDataKHR::initialize(const safe_VkAccelerationStructureGeometryAabbsDataKHR* copy_src)
{
sType = copy_src->sType;
data.initialize(&copy_src->data);
stride = copy_src->stride;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct) :
sType(in_struct->sType),
arrayOfPointers(in_struct->arrayOfPointers),
data(&in_struct->data)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR),
pNext(nullptr)
{}
safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR(const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src)
{
sType = copy_src.sType;
arrayOfPointers = copy_src.arrayOfPointers;
data.initialize(&copy_src.data);
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureGeometryInstancesDataKHR& safe_VkAccelerationStructureGeometryInstancesDataKHR::operator=(const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
arrayOfPointers = copy_src.arrayOfPointers;
data.initialize(&copy_src.data);
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureGeometryInstancesDataKHR::~safe_VkAccelerationStructureGeometryInstancesDataKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureGeometryInstancesDataKHR::initialize(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct)
{
sType = in_struct->sType;
arrayOfPointers = in_struct->arrayOfPointers;
data.initialize(&in_struct->data);
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureGeometryInstancesDataKHR::initialize(const safe_VkAccelerationStructureGeometryInstancesDataKHR* copy_src)
{
sType = copy_src->sType;
arrayOfPointers = copy_src->arrayOfPointers;
data.initialize(&copy_src->data);
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR* in_struct) :
sType(in_struct->sType),
geometryType(in_struct->geometryType),
geometry(in_struct->geometry),
flags(in_struct->flags)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR),
pNext(nullptr)
{}
safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR(const safe_VkAccelerationStructureGeometryKHR& copy_src)
{
sType = copy_src.sType;
geometryType = copy_src.geometryType;
geometry = copy_src.geometry;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR::operator=(const safe_VkAccelerationStructureGeometryKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
geometryType = copy_src.geometryType;
geometry = copy_src.geometry;
flags = copy_src.flags;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureGeometryKHR::~safe_VkAccelerationStructureGeometryKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStructureGeometryKHR* in_struct)
{
sType = in_struct->sType;
geometryType = in_struct->geometryType;
geometry = in_struct->geometry;
flags = in_struct->flags;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerationStructureGeometryKHR* copy_src)
{
sType = copy_src->sType;
geometryType = copy_src->geometryType;
geometry = copy_src->geometry;
flags = copy_src->flags;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct) :
sType(in_struct->sType),
type(in_struct->type),
flags(in_struct->flags),
mode(in_struct->mode),
srcAccelerationStructure(in_struct->srcAccelerationStructure),
dstAccelerationStructure(in_struct->dstAccelerationStructure),
geometryCount(in_struct->geometryCount),
pGeometries(nullptr),
ppGeometries(nullptr),
scratchData(&in_struct->scratchData)
{
pNext = SafePnextCopy(in_struct->pNext);
if (geometryCount) {
if ( in_struct->ppGeometries) {
ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(in_struct->ppGeometries[i]);
}
} else {
pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
(pGeometries)[i] = safe_VkAccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i]);
}
}
}
}
safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR),
pNext(nullptr),
pGeometries(nullptr),
ppGeometries(nullptr)
{}
safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src)
{
sType = copy_src.sType;
type = copy_src.type;
flags = copy_src.flags;
mode = copy_src.mode;
srcAccelerationStructure = copy_src.srcAccelerationStructure;
dstAccelerationStructure = copy_src.dstAccelerationStructure;
geometryCount = copy_src.geometryCount;
pGeometries = nullptr;
ppGeometries = nullptr;
scratchData.initialize(&copy_src.scratchData);
if (geometryCount) {
if ( copy_src.ppGeometries) {
ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]);
}
} else {
pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src.pGeometries[i]);
}
}
}
}
safe_VkAccelerationStructureBuildGeometryInfoKHR& safe_VkAccelerationStructureBuildGeometryInfoKHR::operator=(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (ppGeometries) {
for (uint32_t i = 0; i < geometryCount; ++i) {
delete ppGeometries[i];
}
delete[] ppGeometries;
} else {
delete[] pGeometries;
}
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
type = copy_src.type;
flags = copy_src.flags;
mode = copy_src.mode;
srcAccelerationStructure = copy_src.srcAccelerationStructure;
dstAccelerationStructure = copy_src.dstAccelerationStructure;
geometryCount = copy_src.geometryCount;
pGeometries = nullptr;
ppGeometries = nullptr;
scratchData.initialize(&copy_src.scratchData);
if (geometryCount) {
if ( copy_src.ppGeometries) {
ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]);
}
} else {
pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src.pGeometries[i]);
}
}
}
return *this;
}
safe_VkAccelerationStructureBuildGeometryInfoKHR::~safe_VkAccelerationStructureBuildGeometryInfoKHR()
{
if (ppGeometries) {
for (uint32_t i = 0; i < geometryCount; ++i) {
delete ppGeometries[i];
}
delete[] ppGeometries;
} else {
delete[] pGeometries;
}
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct)
{
sType = in_struct->sType;
type = in_struct->type;
flags = in_struct->flags;
mode = in_struct->mode;
srcAccelerationStructure = in_struct->srcAccelerationStructure;
dstAccelerationStructure = in_struct->dstAccelerationStructure;
geometryCount = in_struct->geometryCount;
pGeometries = nullptr;
ppGeometries = nullptr;
scratchData.initialize(&in_struct->scratchData);
pNext = SafePnextCopy(in_struct->pNext);
if (geometryCount) {
if ( in_struct->ppGeometries) {
ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(in_struct->ppGeometries[i]);
}
} else {
pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
(pGeometries)[i] = safe_VkAccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i]);
}
}
}
}
void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const safe_VkAccelerationStructureBuildGeometryInfoKHR* copy_src)
{
sType = copy_src->sType;
type = copy_src->type;
flags = copy_src->flags;
mode = copy_src->mode;
srcAccelerationStructure = copy_src->srcAccelerationStructure;
dstAccelerationStructure = copy_src->dstAccelerationStructure;
geometryCount = copy_src->geometryCount;
pGeometries = nullptr;
ppGeometries = nullptr;
scratchData.initialize(&copy_src->scratchData);
if (geometryCount) {
if ( copy_src->ppGeometries) {
ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src->ppGeometries[i]);
}
} else {
pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
for (uint32_t i = 0; i < geometryCount; ++i) {
pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src->pGeometries[i]);
}
}
}
}
safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR* in_struct) :
sType(in_struct->sType),
createFlags(in_struct->createFlags),
buffer(in_struct->buffer),
offset(in_struct->offset),
size(in_struct->size),
type(in_struct->type),
deviceAddress(in_struct->deviceAddress)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR(const safe_VkAccelerationStructureCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
createFlags = copy_src.createFlags;
buffer = copy_src.buffer;
offset = copy_src.offset;
size = copy_src.size;
type = copy_src.type;
deviceAddress = copy_src.deviceAddress;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureCreateInfoKHR& safe_VkAccelerationStructureCreateInfoKHR::operator=(const safe_VkAccelerationStructureCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
createFlags = copy_src.createFlags;
buffer = copy_src.buffer;
offset = copy_src.offset;
size = copy_src.size;
type = copy_src.type;
deviceAddress = copy_src.deviceAddress;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureCreateInfoKHR::~safe_VkAccelerationStructureCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureCreateInfoKHR::initialize(const VkAccelerationStructureCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
createFlags = in_struct->createFlags;
buffer = in_struct->buffer;
offset = in_struct->offset;
size = in_struct->size;
type = in_struct->type;
deviceAddress = in_struct->deviceAddress;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureCreateInfoKHR::initialize(const safe_VkAccelerationStructureCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
createFlags = copy_src->createFlags;
buffer = copy_src->buffer;
offset = copy_src->offset;
size = copy_src->size;
type = copy_src->type;
deviceAddress = copy_src->deviceAddress;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct) :
sType(in_struct->sType),
accelerationStructureCount(in_struct->accelerationStructureCount),
pAccelerationStructures(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (accelerationStructureCount && in_struct->pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
}
}
}
safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR() :
sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR),
pNext(nullptr),
pAccelerationStructures(nullptr)
{}
safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR(const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src)
{
sType = copy_src.sType;
accelerationStructureCount = copy_src.accelerationStructureCount;
pAccelerationStructures = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (accelerationStructureCount && copy_src.pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = copy_src.pAccelerationStructures[i];
}
}
}
safe_VkWriteDescriptorSetAccelerationStructureKHR& safe_VkWriteDescriptorSetAccelerationStructureKHR::operator=(const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pAccelerationStructures)
delete[] pAccelerationStructures;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
accelerationStructureCount = copy_src.accelerationStructureCount;
pAccelerationStructures = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (accelerationStructureCount && copy_src.pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = copy_src.pAccelerationStructures[i];
}
}
return *this;
}
safe_VkWriteDescriptorSetAccelerationStructureKHR::~safe_VkWriteDescriptorSetAccelerationStructureKHR()
{
if (pAccelerationStructures)
delete[] pAccelerationStructures;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkWriteDescriptorSetAccelerationStructureKHR::initialize(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct)
{
sType = in_struct->sType;
accelerationStructureCount = in_struct->accelerationStructureCount;
pAccelerationStructures = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (accelerationStructureCount && in_struct->pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
}
}
}
void safe_VkWriteDescriptorSetAccelerationStructureKHR::initialize(const safe_VkWriteDescriptorSetAccelerationStructureKHR* copy_src)
{
sType = copy_src->sType;
accelerationStructureCount = copy_src->accelerationStructureCount;
pAccelerationStructures = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (accelerationStructureCount && copy_src->pAccelerationStructures) {
pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
pAccelerationStructures[i] = copy_src->pAccelerationStructures[i];
}
}
}
safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct) :
sType(in_struct->sType),
accelerationStructure(in_struct->accelerationStructure),
accelerationStructureCaptureReplay(in_struct->accelerationStructureCaptureReplay),
accelerationStructureIndirectBuild(in_struct->accelerationStructureIndirectBuild),
accelerationStructureHostCommands(in_struct->accelerationStructureHostCommands),
descriptorBindingAccelerationStructureUpdateAfterBind(in_struct->descriptorBindingAccelerationStructureUpdateAfterBind)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src)
{
sType = copy_src.sType;
accelerationStructure = copy_src.accelerationStructure;
accelerationStructureCaptureReplay = copy_src.accelerationStructureCaptureReplay;
accelerationStructureIndirectBuild = copy_src.accelerationStructureIndirectBuild;
accelerationStructureHostCommands = copy_src.accelerationStructureHostCommands;
descriptorBindingAccelerationStructureUpdateAfterBind = copy_src.descriptorBindingAccelerationStructureUpdateAfterBind;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::operator=(const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
accelerationStructure = copy_src.accelerationStructure;
accelerationStructureCaptureReplay = copy_src.accelerationStructureCaptureReplay;
accelerationStructureIndirectBuild = copy_src.accelerationStructureIndirectBuild;
accelerationStructureHostCommands = copy_src.accelerationStructureHostCommands;
descriptorBindingAccelerationStructureUpdateAfterBind = copy_src.descriptorBindingAccelerationStructureUpdateAfterBind;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::~safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::initialize(const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct)
{
sType = in_struct->sType;
accelerationStructure = in_struct->accelerationStructure;
accelerationStructureCaptureReplay = in_struct->accelerationStructureCaptureReplay;
accelerationStructureIndirectBuild = in_struct->accelerationStructureIndirectBuild;
accelerationStructureHostCommands = in_struct->accelerationStructureHostCommands;
descriptorBindingAccelerationStructureUpdateAfterBind = in_struct->descriptorBindingAccelerationStructureUpdateAfterBind;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::initialize(const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR* copy_src)
{
sType = copy_src->sType;
accelerationStructure = copy_src->accelerationStructure;
accelerationStructureCaptureReplay = copy_src->accelerationStructureCaptureReplay;
accelerationStructureIndirectBuild = copy_src->accelerationStructureIndirectBuild;
accelerationStructureHostCommands = copy_src->accelerationStructureHostCommands;
descriptorBindingAccelerationStructureUpdateAfterBind = copy_src->descriptorBindingAccelerationStructureUpdateAfterBind;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct) :
sType(in_struct->sType),
maxGeometryCount(in_struct->maxGeometryCount),
maxInstanceCount(in_struct->maxInstanceCount),
maxPrimitiveCount(in_struct->maxPrimitiveCount),
maxPerStageDescriptorAccelerationStructures(in_struct->maxPerStageDescriptorAccelerationStructures),
maxPerStageDescriptorUpdateAfterBindAccelerationStructures(in_struct->maxPerStageDescriptorUpdateAfterBindAccelerationStructures),
maxDescriptorSetAccelerationStructures(in_struct->maxDescriptorSetAccelerationStructures),
maxDescriptorSetUpdateAfterBindAccelerationStructures(in_struct->maxDescriptorSetUpdateAfterBindAccelerationStructures),
minAccelerationStructureScratchOffsetAlignment(in_struct->minAccelerationStructureScratchOffsetAlignment)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src)
{
sType = copy_src.sType;
maxGeometryCount = copy_src.maxGeometryCount;
maxInstanceCount = copy_src.maxInstanceCount;
maxPrimitiveCount = copy_src.maxPrimitiveCount;
maxPerStageDescriptorAccelerationStructures = copy_src.maxPerStageDescriptorAccelerationStructures;
maxPerStageDescriptorUpdateAfterBindAccelerationStructures = copy_src.maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures;
maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src.maxDescriptorSetUpdateAfterBindAccelerationStructures;
minAccelerationStructureScratchOffsetAlignment = copy_src.minAccelerationStructureScratchOffsetAlignment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::operator=(const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxGeometryCount = copy_src.maxGeometryCount;
maxInstanceCount = copy_src.maxInstanceCount;
maxPrimitiveCount = copy_src.maxPrimitiveCount;
maxPerStageDescriptorAccelerationStructures = copy_src.maxPerStageDescriptorAccelerationStructures;
maxPerStageDescriptorUpdateAfterBindAccelerationStructures = copy_src.maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures;
maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src.maxDescriptorSetUpdateAfterBindAccelerationStructures;
minAccelerationStructureScratchOffsetAlignment = copy_src.minAccelerationStructureScratchOffsetAlignment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::~safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::initialize(const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct)
{
sType = in_struct->sType;
maxGeometryCount = in_struct->maxGeometryCount;
maxInstanceCount = in_struct->maxInstanceCount;
maxPrimitiveCount = in_struct->maxPrimitiveCount;
maxPerStageDescriptorAccelerationStructures = in_struct->maxPerStageDescriptorAccelerationStructures;
maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_struct->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
maxDescriptorSetAccelerationStructures = in_struct->maxDescriptorSetAccelerationStructures;
maxDescriptorSetUpdateAfterBindAccelerationStructures = in_struct->maxDescriptorSetUpdateAfterBindAccelerationStructures;
minAccelerationStructureScratchOffsetAlignment = in_struct->minAccelerationStructureScratchOffsetAlignment;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::initialize(const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR* copy_src)
{
sType = copy_src->sType;
maxGeometryCount = copy_src->maxGeometryCount;
maxInstanceCount = copy_src->maxInstanceCount;
maxPrimitiveCount = copy_src->maxPrimitiveCount;
maxPerStageDescriptorAccelerationStructures = copy_src->maxPerStageDescriptorAccelerationStructures;
maxPerStageDescriptorUpdateAfterBindAccelerationStructures = copy_src->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
maxDescriptorSetAccelerationStructures = copy_src->maxDescriptorSetAccelerationStructures;
maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src->maxDescriptorSetUpdateAfterBindAccelerationStructures;
minAccelerationStructureScratchOffsetAlignment = copy_src->minAccelerationStructureScratchOffsetAlignment;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct) :
sType(in_struct->sType),
accelerationStructure(in_struct->accelerationStructure)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR),
pNext(nullptr)
{}
safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR(const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src)
{
sType = copy_src.sType;
accelerationStructure = copy_src.accelerationStructure;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureDeviceAddressInfoKHR& safe_VkAccelerationStructureDeviceAddressInfoKHR::operator=(const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
accelerationStructure = copy_src.accelerationStructure;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureDeviceAddressInfoKHR::~safe_VkAccelerationStructureDeviceAddressInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureDeviceAddressInfoKHR::initialize(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct)
{
sType = in_struct->sType;
accelerationStructure = in_struct->accelerationStructure;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureDeviceAddressInfoKHR::initialize(const safe_VkAccelerationStructureDeviceAddressInfoKHR* copy_src)
{
sType = copy_src->sType;
accelerationStructure = copy_src->accelerationStructure;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR(const VkAccelerationStructureVersionInfoKHR* in_struct) :
sType(in_struct->sType),
pVersionData(nullptr)
{
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVersionData) {
pVersionData = new uint8_t[2*VK_UUID_SIZE];
memcpy ((void *)pVersionData, (void *)in_struct->pVersionData, sizeof(uint8_t)*2*VK_UUID_SIZE);
}
}
safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR),
pNext(nullptr),
pVersionData(nullptr)
{}
safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR(const safe_VkAccelerationStructureVersionInfoKHR& copy_src)
{
sType = copy_src.sType;
pVersionData = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVersionData) {
pVersionData = new uint8_t[2*VK_UUID_SIZE];
memcpy ((void *)pVersionData, (void *)copy_src.pVersionData, sizeof(uint8_t)*2*VK_UUID_SIZE);
}
}
safe_VkAccelerationStructureVersionInfoKHR& safe_VkAccelerationStructureVersionInfoKHR::operator=(const safe_VkAccelerationStructureVersionInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pVersionData)
delete[] pVersionData;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
pVersionData = nullptr;
pNext = SafePnextCopy(copy_src.pNext);
if (copy_src.pVersionData) {
pVersionData = new uint8_t[2*VK_UUID_SIZE];
memcpy ((void *)pVersionData, (void *)copy_src.pVersionData, sizeof(uint8_t)*2*VK_UUID_SIZE);
}
return *this;
}
safe_VkAccelerationStructureVersionInfoKHR::~safe_VkAccelerationStructureVersionInfoKHR()
{
if (pVersionData)
delete[] pVersionData;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureVersionInfoKHR::initialize(const VkAccelerationStructureVersionInfoKHR* in_struct)
{
sType = in_struct->sType;
pVersionData = nullptr;
pNext = SafePnextCopy(in_struct->pNext);
if (in_struct->pVersionData) {
pVersionData = new uint8_t[2*VK_UUID_SIZE];
memcpy ((void *)pVersionData, (void *)in_struct->pVersionData, sizeof(uint8_t)*2*VK_UUID_SIZE);
}
}
void safe_VkAccelerationStructureVersionInfoKHR::initialize(const safe_VkAccelerationStructureVersionInfoKHR* copy_src)
{
sType = copy_src->sType;
pVersionData = nullptr;
pNext = SafePnextCopy(copy_src->pNext);
if (copy_src->pVersionData) {
pVersionData = new uint8_t[2*VK_UUID_SIZE];
memcpy ((void *)pVersionData, (void *)copy_src->pVersionData, sizeof(uint8_t)*2*VK_UUID_SIZE);
}
}
safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct) :
sType(in_struct->sType),
src(in_struct->src),
dst(&in_struct->dst),
mode(in_struct->mode)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR() :
sType(VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR),
pNext(nullptr)
{}
safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src)
{
sType = copy_src.sType;
src = copy_src.src;
dst.initialize(&copy_src.dst);
mode = copy_src.mode;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCopyAccelerationStructureToMemoryInfoKHR& safe_VkCopyAccelerationStructureToMemoryInfoKHR::operator=(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
src = copy_src.src;
dst.initialize(&copy_src.dst);
mode = copy_src.mode;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCopyAccelerationStructureToMemoryInfoKHR::~safe_VkCopyAccelerationStructureToMemoryInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyAccelerationStructureToMemoryInfoKHR::initialize(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct)
{
sType = in_struct->sType;
src = in_struct->src;
dst.initialize(&in_struct->dst);
mode = in_struct->mode;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCopyAccelerationStructureToMemoryInfoKHR::initialize(const safe_VkCopyAccelerationStructureToMemoryInfoKHR* copy_src)
{
sType = copy_src->sType;
src = copy_src->src;
dst.initialize(&copy_src->dst);
mode = copy_src->mode;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct) :
sType(in_struct->sType),
src(&in_struct->src),
dst(in_struct->dst),
mode(in_struct->mode)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR() :
sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR),
pNext(nullptr)
{}
safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src)
{
sType = copy_src.sType;
src.initialize(&copy_src.src);
dst = copy_src.dst;
mode = copy_src.mode;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCopyMemoryToAccelerationStructureInfoKHR& safe_VkCopyMemoryToAccelerationStructureInfoKHR::operator=(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
src.initialize(&copy_src.src);
dst = copy_src.dst;
mode = copy_src.mode;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCopyMemoryToAccelerationStructureInfoKHR::~safe_VkCopyMemoryToAccelerationStructureInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyMemoryToAccelerationStructureInfoKHR::initialize(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct)
{
sType = in_struct->sType;
src.initialize(&in_struct->src);
dst = in_struct->dst;
mode = in_struct->mode;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCopyMemoryToAccelerationStructureInfoKHR::initialize(const safe_VkCopyMemoryToAccelerationStructureInfoKHR* copy_src)
{
sType = copy_src->sType;
src.initialize(&copy_src->src);
dst = copy_src->dst;
mode = copy_src->mode;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR* in_struct) :
sType(in_struct->sType),
src(in_struct->src),
dst(in_struct->dst),
mode(in_struct->mode)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR() :
sType(VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR),
pNext(nullptr)
{}
safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR(const safe_VkCopyAccelerationStructureInfoKHR& copy_src)
{
sType = copy_src.sType;
src = copy_src.src;
dst = copy_src.dst;
mode = copy_src.mode;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCopyAccelerationStructureInfoKHR& safe_VkCopyAccelerationStructureInfoKHR::operator=(const safe_VkCopyAccelerationStructureInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
src = copy_src.src;
dst = copy_src.dst;
mode = copy_src.mode;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCopyAccelerationStructureInfoKHR::~safe_VkCopyAccelerationStructureInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkCopyAccelerationStructureInfoKHR::initialize(const VkCopyAccelerationStructureInfoKHR* in_struct)
{
sType = in_struct->sType;
src = in_struct->src;
dst = in_struct->dst;
mode = in_struct->mode;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkCopyAccelerationStructureInfoKHR::initialize(const safe_VkCopyAccelerationStructureInfoKHR* copy_src)
{
sType = copy_src->sType;
src = copy_src->src;
dst = copy_src->dst;
mode = copy_src->mode;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR* in_struct) :
sType(in_struct->sType),
accelerationStructureSize(in_struct->accelerationStructureSize),
updateScratchSize(in_struct->updateScratchSize),
buildScratchSize(in_struct->buildScratchSize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR() :
sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR),
pNext(nullptr)
{}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src)
{
sType = copy_src.sType;
accelerationStructureSize = copy_src.accelerationStructureSize;
updateScratchSize = copy_src.updateScratchSize;
buildScratchSize = copy_src.buildScratchSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureBuildSizesInfoKHR& safe_VkAccelerationStructureBuildSizesInfoKHR::operator=(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
accelerationStructureSize = copy_src.accelerationStructureSize;
updateScratchSize = copy_src.updateScratchSize;
buildScratchSize = copy_src.buildScratchSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureBuildSizesInfoKHR::~safe_VkAccelerationStructureBuildSizesInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct)
{
sType = in_struct->sType;
accelerationStructureSize = in_struct->accelerationStructureSize;
updateScratchSize = in_struct->updateScratchSize;
buildScratchSize = in_struct->buildScratchSize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src)
{
sType = copy_src->sType;
accelerationStructureSize = copy_src->accelerationStructureSize;
updateScratchSize = copy_src->updateScratchSize;
buildScratchSize = copy_src->buildScratchSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR* in_struct) :
sType(in_struct->sType),
type(in_struct->type),
generalShader(in_struct->generalShader),
closestHitShader(in_struct->closestHitShader),
anyHitShader(in_struct->anyHitShader),
intersectionShader(in_struct->intersectionShader),
pShaderGroupCaptureReplayHandle(in_struct->pShaderGroupCaptureReplayHandle)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR),
pNext(nullptr),
pShaderGroupCaptureReplayHandle(nullptr)
{}
safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR(const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
type = copy_src.type;
generalShader = copy_src.generalShader;
closestHitShader = copy_src.closestHitShader;
anyHitShader = copy_src.anyHitShader;
intersectionShader = copy_src.intersectionShader;
pShaderGroupCaptureReplayHandle = copy_src.pShaderGroupCaptureReplayHandle;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkRayTracingShaderGroupCreateInfoKHR& safe_VkRayTracingShaderGroupCreateInfoKHR::operator=(const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
type = copy_src.type;
generalShader = copy_src.generalShader;
closestHitShader = copy_src.closestHitShader;
anyHitShader = copy_src.anyHitShader;
intersectionShader = copy_src.intersectionShader;
pShaderGroupCaptureReplayHandle = copy_src.pShaderGroupCaptureReplayHandle;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkRayTracingShaderGroupCreateInfoKHR::~safe_VkRayTracingShaderGroupCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRayTracingShaderGroupCreateInfoKHR::initialize(const VkRayTracingShaderGroupCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
type = in_struct->type;
generalShader = in_struct->generalShader;
closestHitShader = in_struct->closestHitShader;
anyHitShader = in_struct->anyHitShader;
intersectionShader = in_struct->intersectionShader;
pShaderGroupCaptureReplayHandle = in_struct->pShaderGroupCaptureReplayHandle;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkRayTracingShaderGroupCreateInfoKHR::initialize(const safe_VkRayTracingShaderGroupCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
type = copy_src->type;
generalShader = copy_src->generalShader;
closestHitShader = copy_src->closestHitShader;
anyHitShader = copy_src->anyHitShader;
intersectionShader = copy_src->intersectionShader;
pShaderGroupCaptureReplayHandle = copy_src->pShaderGroupCaptureReplayHandle;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct) :
sType(in_struct->sType),
maxPipelineRayPayloadSize(in_struct->maxPipelineRayPayloadSize),
maxPipelineRayHitAttributeSize(in_struct->maxPipelineRayHitAttributeSize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR),
pNext(nullptr)
{}
safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
maxPipelineRayPayloadSize = copy_src.maxPipelineRayPayloadSize;
maxPipelineRayHitAttributeSize = copy_src.maxPipelineRayHitAttributeSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkRayTracingPipelineInterfaceCreateInfoKHR& safe_VkRayTracingPipelineInterfaceCreateInfoKHR::operator=(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
maxPipelineRayPayloadSize = copy_src.maxPipelineRayPayloadSize;
maxPipelineRayHitAttributeSize = copy_src.maxPipelineRayHitAttributeSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkRayTracingPipelineInterfaceCreateInfoKHR::~safe_VkRayTracingPipelineInterfaceCreateInfoKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
maxPipelineRayPayloadSize = in_struct->maxPipelineRayPayloadSize;
maxPipelineRayHitAttributeSize = in_struct->maxPipelineRayHitAttributeSize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
maxPipelineRayPayloadSize = copy_src->maxPipelineRayPayloadSize;
maxPipelineRayHitAttributeSize = copy_src->maxPipelineRayHitAttributeSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* in_struct) :
sType(in_struct->sType),
flags(in_struct->flags),
stageCount(in_struct->stageCount),
pStages(nullptr),
groupCount(in_struct->groupCount),
pGroups(nullptr),
maxPipelineRayRecursionDepth(in_struct->maxPipelineRayRecursionDepth),
pLibraryInfo(nullptr),
pLibraryInterface(nullptr),
pDynamicState(nullptr),
layout(in_struct->layout),
basePipelineHandle(in_struct->basePipelineHandle),
basePipelineIndex(in_struct->basePipelineIndex)
{
pNext = SafePnextCopy(in_struct->pNext);
if (stageCount && in_struct->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&in_struct->pStages[i]);
}
}
if (groupCount && in_struct->pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&in_struct->pGroups[i]);
}
}
if (in_struct->pLibraryInfo)
pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
if (in_struct->pLibraryInterface)
pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface);
if (in_struct->pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
}
safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR() :
sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR),
pNext(nullptr),
pStages(nullptr),
pGroups(nullptr),
pLibraryInfo(nullptr),
pLibraryInterface(nullptr),
pDynamicState(nullptr)
{}
safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src)
{
sType = copy_src.sType;
flags = copy_src.flags;
stageCount = copy_src.stageCount;
pStages = nullptr;
groupCount = copy_src.groupCount;
pGroups = nullptr;
maxPipelineRayRecursionDepth = copy_src.maxPipelineRayRecursionDepth;
pLibraryInfo = nullptr;
pLibraryInterface = nullptr;
pDynamicState = nullptr;
layout = copy_src.layout;
basePipelineHandle = copy_src.basePipelineHandle;
basePipelineIndex = copy_src.basePipelineIndex;
pNext = SafePnextCopy(copy_src.pNext);
if (stageCount && copy_src.pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src.pStages[i]);
}
}
if (groupCount && copy_src.pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src.pGroups[i]);
}
}
if (copy_src.pLibraryInfo)
pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
if (copy_src.pLibraryInterface)
pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface);
if (copy_src.pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
}
safe_VkRayTracingPipelineCreateInfoKHR& safe_VkRayTracingPipelineCreateInfoKHR::operator=(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pStages)
delete[] pStages;
if (pGroups)
delete[] pGroups;
if (pLibraryInfo)
delete pLibraryInfo;
if (pLibraryInterface)
delete pLibraryInterface;
if (pDynamicState)
delete pDynamicState;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
stageCount = copy_src.stageCount;
pStages = nullptr;
groupCount = copy_src.groupCount;
pGroups = nullptr;
maxPipelineRayRecursionDepth = copy_src.maxPipelineRayRecursionDepth;
pLibraryInfo = nullptr;
pLibraryInterface = nullptr;
pDynamicState = nullptr;
layout = copy_src.layout;
basePipelineHandle = copy_src.basePipelineHandle;
basePipelineIndex = copy_src.basePipelineIndex;
pNext = SafePnextCopy(copy_src.pNext);
if (stageCount && copy_src.pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src.pStages[i]);
}
}
if (groupCount && copy_src.pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src.pGroups[i]);
}
}
if (copy_src.pLibraryInfo)
pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
if (copy_src.pLibraryInterface)
pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface);
if (copy_src.pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
return *this;
}
safe_VkRayTracingPipelineCreateInfoKHR::~safe_VkRayTracingPipelineCreateInfoKHR()
{
if (pStages)
delete[] pStages;
if (pGroups)
delete[] pGroups;
if (pLibraryInfo)
delete pLibraryInfo;
if (pLibraryInterface)
delete pLibraryInterface;
if (pDynamicState)
delete pDynamicState;
if (pNext)
FreePnextChain(pNext);
}
void safe_VkRayTracingPipelineCreateInfoKHR::initialize(const VkRayTracingPipelineCreateInfoKHR* in_struct)
{
sType = in_struct->sType;
flags = in_struct->flags;
stageCount = in_struct->stageCount;
pStages = nullptr;
groupCount = in_struct->groupCount;
pGroups = nullptr;
maxPipelineRayRecursionDepth = in_struct->maxPipelineRayRecursionDepth;
pLibraryInfo = nullptr;
pLibraryInterface = nullptr;
pDynamicState = nullptr;
layout = in_struct->layout;
basePipelineHandle = in_struct->basePipelineHandle;
basePipelineIndex = in_struct->basePipelineIndex;
pNext = SafePnextCopy(in_struct->pNext);
if (stageCount && in_struct->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&in_struct->pStages[i]);
}
}
if (groupCount && in_struct->pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&in_struct->pGroups[i]);
}
}
if (in_struct->pLibraryInfo)
pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
if (in_struct->pLibraryInterface)
pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface);
if (in_struct->pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
}
void safe_VkRayTracingPipelineCreateInfoKHR::initialize(const safe_VkRayTracingPipelineCreateInfoKHR* copy_src)
{
sType = copy_src->sType;
flags = copy_src->flags;
stageCount = copy_src->stageCount;
pStages = nullptr;
groupCount = copy_src->groupCount;
pGroups = nullptr;
maxPipelineRayRecursionDepth = copy_src->maxPipelineRayRecursionDepth;
pLibraryInfo = nullptr;
pLibraryInterface = nullptr;
pDynamicState = nullptr;
layout = copy_src->layout;
basePipelineHandle = copy_src->basePipelineHandle;
basePipelineIndex = copy_src->basePipelineIndex;
pNext = SafePnextCopy(copy_src->pNext);
if (stageCount && copy_src->pStages) {
pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
for (uint32_t i = 0; i < stageCount; ++i) {
pStages[i].initialize(&copy_src->pStages[i]);
}
}
if (groupCount && copy_src->pGroups) {
pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
for (uint32_t i = 0; i < groupCount; ++i) {
pGroups[i].initialize(&copy_src->pGroups[i]);
}
}
if (copy_src->pLibraryInfo)
pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src->pLibraryInfo);
if (copy_src->pLibraryInterface)
pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src->pLibraryInterface);
if (copy_src->pDynamicState)
pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src->pDynamicState);
}
safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct) :
sType(in_struct->sType),
rayTracingPipeline(in_struct->rayTracingPipeline),
rayTracingPipelineShaderGroupHandleCaptureReplay(in_struct->rayTracingPipelineShaderGroupHandleCaptureReplay),
rayTracingPipelineShaderGroupHandleCaptureReplayMixed(in_struct->rayTracingPipelineShaderGroupHandleCaptureReplayMixed),
rayTracingPipelineTraceRaysIndirect(in_struct->rayTracingPipelineTraceRaysIndirect),
rayTraversalPrimitiveCulling(in_struct->rayTraversalPrimitiveCulling)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src)
{
sType = copy_src.sType;
rayTracingPipeline = copy_src.rayTracingPipeline;
rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplay;
rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
rayTracingPipelineTraceRaysIndirect = copy_src.rayTracingPipelineTraceRaysIndirect;
rayTraversalPrimitiveCulling = copy_src.rayTraversalPrimitiveCulling;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::operator=(const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
rayTracingPipeline = copy_src.rayTracingPipeline;
rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplay;
rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
rayTracingPipelineTraceRaysIndirect = copy_src.rayTracingPipelineTraceRaysIndirect;
rayTraversalPrimitiveCulling = copy_src.rayTraversalPrimitiveCulling;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::initialize(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct)
{
sType = in_struct->sType;
rayTracingPipeline = in_struct->rayTracingPipeline;
rayTracingPipelineShaderGroupHandleCaptureReplay = in_struct->rayTracingPipelineShaderGroupHandleCaptureReplay;
rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_struct->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
rayTracingPipelineTraceRaysIndirect = in_struct->rayTracingPipelineTraceRaysIndirect;
rayTraversalPrimitiveCulling = in_struct->rayTraversalPrimitiveCulling;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::initialize(const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR* copy_src)
{
sType = copy_src->sType;
rayTracingPipeline = copy_src->rayTracingPipeline;
rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src->rayTracingPipelineShaderGroupHandleCaptureReplay;
rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
rayTracingPipelineTraceRaysIndirect = copy_src->rayTracingPipelineTraceRaysIndirect;
rayTraversalPrimitiveCulling = copy_src->rayTraversalPrimitiveCulling;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct) :
sType(in_struct->sType),
shaderGroupHandleSize(in_struct->shaderGroupHandleSize),
maxRayRecursionDepth(in_struct->maxRayRecursionDepth),
maxShaderGroupStride(in_struct->maxShaderGroupStride),
shaderGroupBaseAlignment(in_struct->shaderGroupBaseAlignment),
shaderGroupHandleCaptureReplaySize(in_struct->shaderGroupHandleCaptureReplaySize),
maxRayDispatchInvocationCount(in_struct->maxRayDispatchInvocationCount),
shaderGroupHandleAlignment(in_struct->shaderGroupHandleAlignment),
maxRayHitAttributeSize(in_struct->maxRayHitAttributeSize)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src)
{
sType = copy_src.sType;
shaderGroupHandleSize = copy_src.shaderGroupHandleSize;
maxRayRecursionDepth = copy_src.maxRayRecursionDepth;
maxShaderGroupStride = copy_src.maxShaderGroupStride;
shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment;
shaderGroupHandleCaptureReplaySize = copy_src.shaderGroupHandleCaptureReplaySize;
maxRayDispatchInvocationCount = copy_src.maxRayDispatchInvocationCount;
shaderGroupHandleAlignment = copy_src.shaderGroupHandleAlignment;
maxRayHitAttributeSize = copy_src.maxRayHitAttributeSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::operator=(const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
shaderGroupHandleSize = copy_src.shaderGroupHandleSize;
maxRayRecursionDepth = copy_src.maxRayRecursionDepth;
maxShaderGroupStride = copy_src.maxShaderGroupStride;
shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment;
shaderGroupHandleCaptureReplaySize = copy_src.shaderGroupHandleCaptureReplaySize;
maxRayDispatchInvocationCount = copy_src.maxRayDispatchInvocationCount;
shaderGroupHandleAlignment = copy_src.shaderGroupHandleAlignment;
maxRayHitAttributeSize = copy_src.maxRayHitAttributeSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::~safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::initialize(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct)
{
sType = in_struct->sType;
shaderGroupHandleSize = in_struct->shaderGroupHandleSize;
maxRayRecursionDepth = in_struct->maxRayRecursionDepth;
maxShaderGroupStride = in_struct->maxShaderGroupStride;
shaderGroupBaseAlignment = in_struct->shaderGroupBaseAlignment;
shaderGroupHandleCaptureReplaySize = in_struct->shaderGroupHandleCaptureReplaySize;
maxRayDispatchInvocationCount = in_struct->maxRayDispatchInvocationCount;
shaderGroupHandleAlignment = in_struct->shaderGroupHandleAlignment;
maxRayHitAttributeSize = in_struct->maxRayHitAttributeSize;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::initialize(const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* copy_src)
{
sType = copy_src->sType;
shaderGroupHandleSize = copy_src->shaderGroupHandleSize;
maxRayRecursionDepth = copy_src->maxRayRecursionDepth;
maxShaderGroupStride = copy_src->maxShaderGroupStride;
shaderGroupBaseAlignment = copy_src->shaderGroupBaseAlignment;
shaderGroupHandleCaptureReplaySize = copy_src->shaderGroupHandleCaptureReplaySize;
maxRayDispatchInvocationCount = copy_src->maxRayDispatchInvocationCount;
shaderGroupHandleAlignment = copy_src->shaderGroupHandleAlignment;
maxRayHitAttributeSize = copy_src->maxRayHitAttributeSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct) :
sType(in_struct->sType),
rayQuery(in_struct->rayQuery)
{
pNext = SafePnextCopy(in_struct->pNext);
}
safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR() :
sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR),
pNext(nullptr)
{}
safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR(const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src)
{
sType = copy_src.sType;
rayQuery = copy_src.rayQuery;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceRayQueryFeaturesKHR& safe_VkPhysicalDeviceRayQueryFeaturesKHR::operator=(const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src)
{
if (&copy_src == this) return *this;
if (pNext)
FreePnextChain(pNext);
sType = copy_src.sType;
rayQuery = copy_src.rayQuery;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceRayQueryFeaturesKHR::~safe_VkPhysicalDeviceRayQueryFeaturesKHR()
{
if (pNext)
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceRayQueryFeaturesKHR::initialize(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct)
{
sType = in_struct->sType;
rayQuery = in_struct->rayQuery;
pNext = SafePnextCopy(in_struct->pNext);
}
void safe_VkPhysicalDeviceRayQueryFeaturesKHR::initialize(const safe_VkPhysicalDeviceRayQueryFeaturesKHR* copy_src)
{
sType = copy_src->sType;
rayQuery = copy_src->rayQuery;
pNext = SafePnextCopy(copy_src->pNext);
}
char *SafeStringCopy(const char *in_string) {
if (nullptr == in_string) return nullptr;
char* dest = new char[std::strlen(in_string) + 1];
return std::strcpy(dest, in_string);
}
void *SafePnextCopy(const void *pNext) {
if (!pNext) return nullptr;
void *safe_pNext{};
const VkBaseOutStructure *header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
switch (header->sType) {
// Special-case Loader Instance Struct passed to/from layer in pNext chain
case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: {
VkLayerInstanceCreateInfo *struct_copy = new VkLayerInstanceCreateInfo;
// TODO: Uses original VkLayerInstanceLink* chain, which should be okay for our uses
memcpy(struct_copy, pNext, sizeof(VkLayerInstanceCreateInfo));
struct_copy->pNext = SafePnextCopy(header->pNext);
safe_pNext = struct_copy;
break;
}
// Special-case Loader Device Struct passed to/from layer in pNext chain
case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: {
VkLayerDeviceCreateInfo *struct_copy = new VkLayerDeviceCreateInfo;
// TODO: Uses original VkLayerDeviceLink*, which should be okay for our uses
memcpy(struct_copy, pNext, sizeof(VkLayerDeviceCreateInfo));
struct_copy->pNext = SafePnextCopy(header->pNext);
safe_pNext = struct_copy;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceSubgroupProperties(reinterpret_cast<const VkPhysicalDeviceSubgroupProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
safe_pNext = new safe_VkPhysicalDevice16BitStorageFeatures(reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
safe_pNext = new safe_VkMemoryDedicatedRequirements(reinterpret_cast<const VkMemoryDedicatedRequirements *>(pNext));
break;
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
safe_pNext = new safe_VkMemoryDedicatedAllocateInfo(reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
safe_pNext = new safe_VkMemoryAllocateFlagsInfo(reinterpret_cast<const VkMemoryAllocateFlagsInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
safe_pNext = new safe_VkDeviceGroupRenderPassBeginInfo(reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
safe_pNext = new safe_VkDeviceGroupCommandBufferBeginInfo(reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
safe_pNext = new safe_VkDeviceGroupSubmitInfo(reinterpret_cast<const VkDeviceGroupSubmitInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
safe_pNext = new safe_VkDeviceGroupBindSparseInfo(reinterpret_cast<const VkDeviceGroupBindSparseInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
safe_pNext = new safe_VkBindBufferMemoryDeviceGroupInfo(reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
safe_pNext = new safe_VkBindImageMemoryDeviceGroupInfo(reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
safe_pNext = new safe_VkDeviceGroupDeviceCreateInfo(reinterpret_cast<const VkDeviceGroupDeviceCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
safe_pNext = new safe_VkPhysicalDeviceFeatures2(reinterpret_cast<const VkPhysicalDeviceFeatures2 *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
safe_pNext = new safe_VkPhysicalDevicePointClippingProperties(reinterpret_cast<const VkPhysicalDevicePointClippingProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
safe_pNext = new safe_VkRenderPassInputAttachmentAspectCreateInfo(reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
safe_pNext = new safe_VkImageViewUsageCreateInfo(reinterpret_cast<const VkImageViewUsageCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
safe_pNext = new safe_VkPipelineTessellationDomainOriginStateCreateInfo(reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
safe_pNext = new safe_VkRenderPassMultiviewCreateInfo(reinterpret_cast<const VkRenderPassMultiviewCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceMultiviewFeatures(reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceMultiviewProperties(reinterpret_cast<const VkPhysicalDeviceMultiviewProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceVariablePointersFeatures(reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceProtectedMemoryFeatures(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceProtectedMemoryProperties(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
safe_pNext = new safe_VkProtectedSubmitInfo(reinterpret_cast<const VkProtectedSubmitInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
safe_pNext = new safe_VkSamplerYcbcrConversionInfo(reinterpret_cast<const VkSamplerYcbcrConversionInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
safe_pNext = new safe_VkBindImagePlaneMemoryInfo(reinterpret_cast<const VkBindImagePlaneMemoryInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
safe_pNext = new safe_VkImagePlaneMemoryRequirementsInfo(reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
safe_pNext = new safe_VkSamplerYcbcrConversionImageFormatProperties(reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
safe_pNext = new safe_VkPhysicalDeviceExternalImageFormatInfo(reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
safe_pNext = new safe_VkExternalImageFormatProperties(reinterpret_cast<const VkExternalImageFormatProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceIDProperties(reinterpret_cast<const VkPhysicalDeviceIDProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
safe_pNext = new safe_VkExternalMemoryImageCreateInfo(reinterpret_cast<const VkExternalMemoryImageCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
safe_pNext = new safe_VkExternalMemoryBufferCreateInfo(reinterpret_cast<const VkExternalMemoryBufferCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
safe_pNext = new safe_VkExportMemoryAllocateInfo(reinterpret_cast<const VkExportMemoryAllocateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
safe_pNext = new safe_VkExportFenceCreateInfo(reinterpret_cast<const VkExportFenceCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
safe_pNext = new safe_VkExportSemaphoreCreateInfo(reinterpret_cast<const VkExportSemaphoreCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceMaintenance3Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceShaderDrawParametersFeatures(reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceVulkan11Features(reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceVulkan11Properties(reinterpret_cast<const VkPhysicalDeviceVulkan11Properties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceVulkan12Features(reinterpret_cast<const VkPhysicalDeviceVulkan12Features *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceVulkan12Properties(reinterpret_cast<const VkPhysicalDeviceVulkan12Properties *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
safe_pNext = new safe_VkImageFormatListCreateInfo(reinterpret_cast<const VkImageFormatListCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
safe_pNext = new safe_VkPhysicalDevice8BitStorageFeatures(reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceDriverProperties(reinterpret_cast<const VkPhysicalDeviceDriverProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceShaderAtomicInt64Features(reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceShaderFloat16Int8Features(reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceFloatControlsProperties(reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
safe_pNext = new safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceDescriptorIndexingFeatures(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceDescriptorIndexingProperties(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
safe_pNext = new safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
safe_pNext = new safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport *>(pNext));
break;
case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
safe_pNext = new safe_VkSubpassDescriptionDepthStencilResolve(reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceDepthStencilResolveProperties(reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceScalarBlockLayoutFeatures(reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
safe_pNext = new safe_VkImageStencilUsageCreateInfo(reinterpret_cast<const VkImageStencilUsageCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
safe_pNext = new safe_VkSamplerReductionModeCreateInfo(reinterpret_cast<const VkSamplerReductionModeCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceVulkanMemoryModelFeatures(reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceImagelessFramebufferFeatures(reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
safe_pNext = new safe_VkFramebufferAttachmentsCreateInfo(reinterpret_cast<const VkFramebufferAttachmentsCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
safe_pNext = new safe_VkRenderPassAttachmentBeginInfo(reinterpret_cast<const VkRenderPassAttachmentBeginInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
safe_pNext = new safe_VkAttachmentReferenceStencilLayout(reinterpret_cast<const VkAttachmentReferenceStencilLayout *>(pNext));
break;
case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
safe_pNext = new safe_VkAttachmentDescriptionStencilLayout(reinterpret_cast<const VkAttachmentDescriptionStencilLayout *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceHostQueryResetFeatures(reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceTimelineSemaphoreFeatures(reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
safe_pNext = new safe_VkPhysicalDeviceTimelineSemaphoreProperties(reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties *>(pNext));
break;
case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
safe_pNext = new safe_VkSemaphoreTypeCreateInfo(reinterpret_cast<const VkSemaphoreTypeCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
safe_pNext = new safe_VkTimelineSemaphoreSubmitInfo(reinterpret_cast<const VkTimelineSemaphoreSubmitInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
safe_pNext = new safe_VkPhysicalDeviceBufferDeviceAddressFeatures(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures *>(pNext));
break;
case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
safe_pNext = new safe_VkBufferOpaqueCaptureAddressCreateInfo(reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
safe_pNext = new safe_VkMemoryOpaqueCaptureAddressAllocateInfo(reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
safe_pNext = new safe_VkImageSwapchainCreateInfoKHR(reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
safe_pNext = new safe_VkBindImageMemorySwapchainInfoKHR(reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
safe_pNext = new safe_VkDeviceGroupPresentInfoKHR(reinterpret_cast<const VkDeviceGroupPresentInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
safe_pNext = new safe_VkDeviceGroupSwapchainCreateInfoKHR(reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
safe_pNext = new safe_VkDisplayPresentInfoKHR(reinterpret_cast<const VkDisplayPresentInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
safe_pNext = new safe_VkImportMemoryFdInfoKHR(reinterpret_cast<const VkImportMemoryFdInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDevicePushDescriptorPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
safe_pNext = new safe_VkPresentRegionsKHR(reinterpret_cast<const VkPresentRegionsKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
safe_pNext = new safe_VkSharedPresentSurfaceCapabilitiesKHR(reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
safe_pNext = new safe_VkQueryPoolPerformanceCreateInfoKHR(reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
safe_pNext = new safe_VkPerformanceQuerySubmitInfoKHR(reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceShaderClockFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
safe_pNext = new safe_VkFragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
safe_pNext = new safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
safe_pNext = new safe_VkSurfaceProtectedCapabilitiesKHR(reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
safe_pNext = new safe_VkMemoryBarrier2KHR(reinterpret_cast<const VkMemoryBarrier2KHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceSynchronization2FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
safe_pNext = new safe_VkQueueFamilyCheckpointProperties2NV(reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
safe_pNext = new safe_VkPipelineRasterizationStateRasterizationOrderAMD(reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
safe_pNext = new safe_VkDedicatedAllocationImageCreateInfoNV(reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
safe_pNext = new safe_VkDedicatedAllocationBufferCreateInfoNV(reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
safe_pNext = new safe_VkDedicatedAllocationMemoryAllocateInfoNV(reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
safe_pNext = new safe_VkTextureLODGatherFormatPropertiesAMD(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
safe_pNext = new safe_VkExternalMemoryImageCreateInfoNV(reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
safe_pNext = new safe_VkExportMemoryAllocateInfoNV(reinterpret_cast<const VkExportMemoryAllocateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
safe_pNext = new safe_VkValidationFlagsEXT(reinterpret_cast<const VkValidationFlagsEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
safe_pNext = new safe_VkImageViewASTCDecodeModeEXT(reinterpret_cast<const VkImageViewASTCDecodeModeEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
safe_pNext = new safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineViewportWScalingStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
safe_pNext = new safe_VkSwapchainCounterCreateInfoEXT(reinterpret_cast<const VkSwapchainCounterCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
safe_pNext = new safe_VkPresentTimesInfoGOOGLE(reinterpret_cast<const VkPresentTimesInfoGOOGLE *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineViewportSwizzleStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineDiscardRectangleStateCreateInfoEXT(reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
safe_pNext = new safe_VkDebugUtilsMessengerCreateInfoEXT(reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
safe_pNext = new safe_VkWriteDescriptorSetInlineUniformBlockEXT(reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
safe_pNext = new safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
safe_pNext = new safe_VkSampleLocationsInfoEXT(reinterpret_cast<const VkSampleLocationsInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
safe_pNext = new safe_VkRenderPassSampleLocationsBeginInfoEXT(reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineSampleLocationsStateCreateInfoEXT(reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineCoverageToColorStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineCoverageModulationStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
safe_pNext = new safe_VkDrmFormatModifierPropertiesListEXT(reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
safe_pNext = new safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
safe_pNext = new safe_VkImageDrmFormatModifierListCreateInfoEXT(reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
safe_pNext = new safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
safe_pNext = new safe_VkShaderModuleValidationCacheCreateInfoEXT(reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceShadingRateImageFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceShadingRateImagePropertiesNV(reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceRayTracingPropertiesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
safe_pNext = new safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
safe_pNext = new safe_VkFilterCubicImageViewImageFormatPropertiesEXT(reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
safe_pNext = new safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
safe_pNext = new safe_VkImportMemoryHostPointerInfoEXT(reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
safe_pNext = new safe_VkPipelineCompilerControlCreateInfoAMD(reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
safe_pNext = new safe_VkPhysicalDeviceShaderCorePropertiesAMD(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
safe_pNext = new safe_VkDeviceMemoryOverallocationCreateInfoAMD(reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineCreationFeedbackCreateInfoEXT(reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceMeshShaderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceMeshShaderPropertiesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
safe_pNext = new safe_VkQueueFamilyCheckpointPropertiesNV(reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
safe_pNext = new safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(pNext));
break;
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
safe_pNext = new safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
safe_pNext = new safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
safe_pNext = new safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
safe_pNext = new safe_VkRenderPassFragmentDensityMapCreateInfoEXT(reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
safe_pNext = new safe_VkPhysicalDeviceShaderCoreProperties2AMD(reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
safe_pNext = new safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
safe_pNext = new safe_VkMemoryPriorityAllocateInfoEXT(reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
safe_pNext = new safe_VkBufferDeviceAddressCreateInfoEXT(reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
safe_pNext = new safe_VkValidationFeaturesEXT(reinterpret_cast<const VkValidationFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineCoverageReductionStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineRasterizationLineStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
safe_pNext = new safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
safe_pNext = new safe_VkCommandBufferInheritanceViewportScissorInfoNV(reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
safe_pNext = new safe_VkRenderPassTransformBeginInfoQCOM(reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM *>(pNext));
break;
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
safe_pNext = new safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
safe_pNext = new safe_VkDeviceDeviceMemoryReportCreateInfoEXT(reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceRobustness2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceRobustness2PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
safe_pNext = new safe_VkSamplerCustomBorderColorCreateInfoEXT(reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDevicePrivateDataFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
safe_pNext = new safe_VkDevicePrivateDataCreateInfoEXT(reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
safe_pNext = new safe_VkDeviceDiagnosticsConfigCreateInfoNV(reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
safe_pNext = new safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
safe_pNext = new safe_VkCopyCommandTransformInfoQCOM(reinterpret_cast<const VkCopyCommandTransformInfoQCOM *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceImageRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDevice4444FormatsFeaturesEXT(reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
safe_pNext = new safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>(pNext));
break;
case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
safe_pNext = new safe_VkMutableDescriptorTypeCreateInfoVALVE(reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineColorWriteCreateInfoEXT(reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceRayQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR *>(pNext));
break;
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
safe_pNext = new safe_VkVideoQueueFamilyProperties2KHR(reinterpret_cast<const VkVideoQueueFamilyProperties2KHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
safe_pNext = new safe_VkVideoProfileKHR(reinterpret_cast<const VkVideoProfileKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
safe_pNext = new safe_VkVideoProfilesKHR(reinterpret_cast<const VkVideoProfilesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeRateControlInfoKHR(reinterpret_cast<const VkVideoEncodeRateControlInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
safe_pNext = new safe_VkVideoEncodeH264CapabilitiesEXT(reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
safe_pNext = new safe_VkVideoEncodeH264SessionCreateInfoEXT(reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
safe_pNext = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
safe_pNext = new safe_VkVideoEncodeH264SessionParametersCreateInfoEXT(reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
safe_pNext = new safe_VkVideoEncodeH264VclFrameInfoEXT(reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
safe_pNext = new safe_VkVideoEncodeH264EmitPictureParametersEXT(reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
safe_pNext = new safe_VkVideoEncodeH264ProfileEXT(reinterpret_cast<const VkVideoEncodeH264ProfileEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
safe_pNext = new safe_VkVideoDecodeH264ProfileEXT(reinterpret_cast<const VkVideoDecodeH264ProfileEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
safe_pNext = new safe_VkVideoDecodeH264CapabilitiesEXT(reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH264SessionCreateInfoEXT(reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH264SessionParametersAddInfoEXT(reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH264SessionParametersCreateInfoEXT(reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH264PictureInfoEXT(reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
safe_pNext = new safe_VkVideoDecodeH264MvcEXT(reinterpret_cast<const VkVideoDecodeH264MvcEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH264DpbSlotInfoEXT(reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
safe_pNext = new safe_VkVideoDecodeH265ProfileEXT(reinterpret_cast<const VkVideoDecodeH265ProfileEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
safe_pNext = new safe_VkVideoDecodeH265CapabilitiesEXT(reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH265SessionCreateInfoEXT(reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH265SessionParametersAddInfoEXT(reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH265SessionParametersCreateInfoEXT(reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH265PictureInfoEXT(reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
safe_pNext = new safe_VkVideoDecodeH265DpbSlotInfoEXT(reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT *>(pNext));
break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_USE_PLATFORM_ANDROID_KHR
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
safe_pNext = new safe_VkAndroidHardwareBufferUsageANDROID(reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID *>(pNext));
break;
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
safe_pNext = new safe_VkAndroidHardwareBufferFormatPropertiesANDROID(reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
safe_pNext = new safe_VkImportAndroidHardwareBufferInfoANDROID(reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
safe_pNext = new safe_VkExternalFormatANDROID(reinterpret_cast<const VkExternalFormatANDROID *>(pNext));
break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_FUCHSIA
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
safe_pNext = new safe_VkImportMemoryZirconHandleInfoFUCHSIA(reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(pNext));
break;
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_GGP
case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
safe_pNext = new safe_VkPresentFrameTokenGGP(reinterpret_cast<const VkPresentFrameTokenGGP *>(pNext));
break;
#endif // VK_USE_PLATFORM_GGP
#ifdef VK_USE_PLATFORM_WIN32_KHR
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
safe_pNext = new safe_VkImportMemoryWin32HandleInfoKHR(reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
safe_pNext = new safe_VkExportMemoryWin32HandleInfoKHR(reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
safe_pNext = new safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
safe_pNext = new safe_VkExportSemaphoreWin32HandleInfoKHR(reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
safe_pNext = new safe_VkD3D12FenceSubmitInfoKHR(reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
safe_pNext = new safe_VkExportFenceWin32HandleInfoKHR(reinterpret_cast<const VkExportFenceWin32HandleInfoKHR *>(pNext));
break;
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
safe_pNext = new safe_VkImportMemoryWin32HandleInfoNV(reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
safe_pNext = new safe_VkExportMemoryWin32HandleInfoNV(reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
safe_pNext = new safe_VkWin32KeyedMutexAcquireReleaseInfoNV(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV *>(pNext));
break;
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
safe_pNext = new safe_VkSurfaceFullScreenExclusiveInfoEXT(reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
safe_pNext = new safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(pNext));
break;
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
safe_pNext = new safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT *>(pNext));
break;
#endif // VK_USE_PLATFORM_WIN32_KHR
default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain
// If sType is in custom list, construct blind copy
for (auto item : custom_stype_info) {
if (item.first == header->sType) {
safe_pNext = malloc(item.second);
memcpy(safe_pNext, header, item.second);
// Deep copy the rest of the pNext chain
VkBaseOutStructure *custom_struct = reinterpret_cast<VkBaseOutStructure *>(safe_pNext);
if (custom_struct->pNext) {
custom_struct->pNext = reinterpret_cast<VkBaseOutStructure *>(SafePnextCopy(custom_struct->pNext));
}
}
}
if (!safe_pNext) {
safe_pNext = SafePnextCopy(header->pNext);
}
break;
}
return safe_pNext;
}
void FreePnextChain(const void *pNext) {
if (!pNext) return;
auto header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
switch (header->sType) {
// Special-case Loader Instance Struct passed to/from layer in pNext chain
case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
FreePnextChain(header->pNext);
delete reinterpret_cast<const VkLayerInstanceCreateInfo *>(pNext);
break;
// Special-case Loader Device Struct passed to/from layer in pNext chain
case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
FreePnextChain(header->pNext);
delete reinterpret_cast<const VkLayerDeviceCreateInfo *>(pNext);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupProperties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDevice16BitStorageFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
delete reinterpret_cast<const safe_VkMemoryDedicatedRequirements *>(header);
break;
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
delete reinterpret_cast<const safe_VkMemoryDedicatedAllocateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
delete reinterpret_cast<const safe_VkMemoryAllocateFlagsInfo *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
delete reinterpret_cast<const safe_VkDeviceGroupRenderPassBeginInfo *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
delete reinterpret_cast<const safe_VkDeviceGroupCommandBufferBeginInfo *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
delete reinterpret_cast<const safe_VkDeviceGroupSubmitInfo *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
delete reinterpret_cast<const safe_VkDeviceGroupBindSparseInfo *>(header);
break;
case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
delete reinterpret_cast<const safe_VkBindBufferMemoryDeviceGroupInfo *>(header);
break;
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
delete reinterpret_cast<const safe_VkBindImageMemoryDeviceGroupInfo *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
delete reinterpret_cast<const safe_VkDeviceGroupDeviceCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
delete reinterpret_cast<const safe_VkPhysicalDeviceFeatures2 *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDevicePointClippingProperties *>(header);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
delete reinterpret_cast<const safe_VkRenderPassInputAttachmentAspectCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
delete reinterpret_cast<const safe_VkImageViewUsageCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
delete reinterpret_cast<const safe_VkPipelineTessellationDomainOriginStateCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
delete reinterpret_cast<const safe_VkRenderPassMultiviewCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewProperties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceVariablePointersFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceProtectedMemoryFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceProtectedMemoryProperties *>(header);
break;
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
delete reinterpret_cast<const safe_VkProtectedSubmitInfo *>(header);
break;
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
delete reinterpret_cast<const safe_VkSamplerYcbcrConversionInfo *>(header);
break;
case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
delete reinterpret_cast<const safe_VkBindImagePlaneMemoryInfo *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
delete reinterpret_cast<const safe_VkImagePlaneMemoryRequirementsInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
delete reinterpret_cast<const safe_VkSamplerYcbcrConversionImageFormatProperties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
delete reinterpret_cast<const safe_VkPhysicalDeviceExternalImageFormatInfo *>(header);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
delete reinterpret_cast<const safe_VkExternalImageFormatProperties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceIDProperties *>(header);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
delete reinterpret_cast<const safe_VkExternalMemoryImageCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
delete reinterpret_cast<const safe_VkExternalMemoryBufferCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
delete reinterpret_cast<const safe_VkExportMemoryAllocateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
delete reinterpret_cast<const safe_VkExportFenceCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
delete reinterpret_cast<const safe_VkExportSemaphoreCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance3Properties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderDrawParametersFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan11Features *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan11Properties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan12Features *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan12Properties *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
delete reinterpret_cast<const safe_VkImageFormatListCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDevice8BitStorageFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceDriverProperties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicInt64Features *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderFloat16Int8Features *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceFloatControlsProperties *>(header);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
delete reinterpret_cast<const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorIndexingFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorIndexingProperties *>(header);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
delete reinterpret_cast<const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
delete reinterpret_cast<const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport *>(header);
break;
case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
delete reinterpret_cast<const safe_VkSubpassDescriptionDepthStencilResolve *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceDepthStencilResolveProperties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceScalarBlockLayoutFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
delete reinterpret_cast<const safe_VkImageStencilUsageCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
delete reinterpret_cast<const safe_VkSamplerReductionModeCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceVulkanMemoryModelFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceImagelessFramebufferFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
delete reinterpret_cast<const safe_VkFramebufferAttachmentsCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
delete reinterpret_cast<const safe_VkRenderPassAttachmentBeginInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
delete reinterpret_cast<const safe_VkAttachmentReferenceStencilLayout *>(header);
break;
case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
delete reinterpret_cast<const safe_VkAttachmentDescriptionStencilLayout *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceHostQueryResetFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceTimelineSemaphoreFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
delete reinterpret_cast<const safe_VkPhysicalDeviceTimelineSemaphoreProperties *>(header);
break;
case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
delete reinterpret_cast<const safe_VkSemaphoreTypeCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
delete reinterpret_cast<const safe_VkTimelineSemaphoreSubmitInfo *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
delete reinterpret_cast<const safe_VkPhysicalDeviceBufferDeviceAddressFeatures *>(header);
break;
case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
delete reinterpret_cast<const safe_VkBufferOpaqueCaptureAddressCreateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
delete reinterpret_cast<const safe_VkMemoryOpaqueCaptureAddressAllocateInfo *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
delete reinterpret_cast<const safe_VkImageSwapchainCreateInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
delete reinterpret_cast<const safe_VkBindImageMemorySwapchainInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
delete reinterpret_cast<const safe_VkDeviceGroupPresentInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
delete reinterpret_cast<const safe_VkDeviceGroupSwapchainCreateInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
delete reinterpret_cast<const safe_VkDisplayPresentInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
delete reinterpret_cast<const safe_VkImportMemoryFdInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDevicePushDescriptorPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
delete reinterpret_cast<const safe_VkPresentRegionsKHR *>(header);
break;
case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
delete reinterpret_cast<const safe_VkSharedPresentSurfaceCapabilitiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
delete reinterpret_cast<const safe_VkQueryPoolPerformanceCreateInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
delete reinterpret_cast<const safe_VkPerformanceQuerySubmitInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderClockFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
delete reinterpret_cast<const safe_VkFragmentShadingRateAttachmentInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
delete reinterpret_cast<const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
delete reinterpret_cast<const safe_VkSurfaceProtectedCapabilitiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
delete reinterpret_cast<const safe_VkMemoryBarrier2KHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceSynchronization2FeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
delete reinterpret_cast<const safe_VkQueueFamilyCheckpointProperties2NV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkDebugReportCallbackCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
delete reinterpret_cast<const safe_VkPipelineRasterizationStateRasterizationOrderAMD *>(header);
break;
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkDedicatedAllocationImageCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkDedicatedAllocationBufferCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
delete reinterpret_cast<const safe_VkDedicatedAllocationMemoryAllocateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
delete reinterpret_cast<const safe_VkTextureLODGatherFormatPropertiesAMD *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkExternalMemoryImageCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
delete reinterpret_cast<const safe_VkExportMemoryAllocateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
delete reinterpret_cast<const safe_VkValidationFlagsEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
delete reinterpret_cast<const safe_VkImageViewASTCDecodeModeEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
delete reinterpret_cast<const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineViewportWScalingStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkSwapchainCounterCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
delete reinterpret_cast<const safe_VkPresentTimesInfoGOOGLE *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineViewportSwizzleStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineDiscardRectangleStateCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkDebugUtilsMessengerCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
delete reinterpret_cast<const safe_VkWriteDescriptorSetInlineUniformBlockEXT *>(header);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
delete reinterpret_cast<const safe_VkSampleLocationsInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
delete reinterpret_cast<const safe_VkRenderPassSampleLocationsBeginInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineSampleLocationsStateCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineCoverageToColorStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineCoverageModulationStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
delete reinterpret_cast<const safe_VkDrmFormatModifierPropertiesListEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkImageDrmFormatModifierListCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkShaderModuleValidationCacheCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceShadingRateImageFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceShadingRateImagePropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkFilterCubicImageViewImageFormatPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
delete reinterpret_cast<const safe_VkImportMemoryHostPointerInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
delete reinterpret_cast<const safe_VkPipelineCompilerControlCreateInfoAMD *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCorePropertiesAMD *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
delete reinterpret_cast<const safe_VkDeviceMemoryOverallocationCreateInfoAMD *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineCreationFeedbackCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
delete reinterpret_cast<const safe_VkQueueFamilyCheckpointPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(header);
break;
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
delete reinterpret_cast<const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
delete reinterpret_cast<const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(header);
break;
case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
delete reinterpret_cast<const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkRenderPassFragmentDensityMapCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCoreProperties2AMD *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
delete reinterpret_cast<const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
delete reinterpret_cast<const safe_VkMemoryPriorityAllocateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkBufferDeviceAddressCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
delete reinterpret_cast<const safe_VkValidationFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineCoverageReductionStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineRasterizationLineStateCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
delete reinterpret_cast<const safe_VkCommandBufferInheritanceViewportScissorInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
delete reinterpret_cast<const safe_VkRenderPassTransformBeginInfoQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
delete reinterpret_cast<const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkDeviceDeviceMemoryReportCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceRobustness2FeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceRobustness2PropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkSamplerCustomBorderColorCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDevicePrivateDataFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkDevicePrivateDataCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkDeviceDiagnosticsConfigCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
delete reinterpret_cast<const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
delete reinterpret_cast<const safe_VkCopyCommandTransformInfoQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceImageRobustnessFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDevice4444FormatsFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
delete reinterpret_cast<const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>(header);
break;
case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
delete reinterpret_cast<const safe_VkMutableDescriptorTypeCreateInfoVALVE *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
delete reinterpret_cast<const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkPipelineColorWriteCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDeviceRayQueryFeaturesKHR *>(header);
break;
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
delete reinterpret_cast<const safe_VkVideoQueueFamilyProperties2KHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
delete reinterpret_cast<const safe_VkVideoProfileKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
delete reinterpret_cast<const safe_VkVideoProfilesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
delete reinterpret_cast<const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
delete reinterpret_cast<const safe_VkVideoEncodeRateControlInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
delete reinterpret_cast<const safe_VkVideoEncodeH264CapabilitiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoEncodeH264SessionCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersAddInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoEncodeH264VclFrameInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
delete reinterpret_cast<const safe_VkVideoEncodeH264EmitPictureParametersEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
delete reinterpret_cast<const safe_VkVideoEncodeH264ProfileEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH264ProfileEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH264CapabilitiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH264SessionCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH264SessionParametersAddInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH264SessionParametersCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH264PictureInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH264MvcEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH264DpbSlotInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH265ProfileEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH265CapabilitiesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH265SessionCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH265SessionParametersAddInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH265SessionParametersCreateInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH265PictureInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
delete reinterpret_cast<const safe_VkVideoDecodeH265DpbSlotInfoEXT *>(header);
break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_USE_PLATFORM_ANDROID_KHR
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
delete reinterpret_cast<const safe_VkAndroidHardwareBufferUsageANDROID *>(header);
break;
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
delete reinterpret_cast<const safe_VkAndroidHardwareBufferFormatPropertiesANDROID *>(header);
break;
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
delete reinterpret_cast<const safe_VkImportAndroidHardwareBufferInfoANDROID *>(header);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
delete reinterpret_cast<const safe_VkExternalFormatANDROID *>(header);
break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_FUCHSIA
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
delete reinterpret_cast<const safe_VkImportMemoryZirconHandleInfoFUCHSIA *>(header);
break;
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_GGP
case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
delete reinterpret_cast<const safe_VkPresentFrameTokenGGP *>(header);
break;
#endif // VK_USE_PLATFORM_GGP
#ifdef VK_USE_PLATFORM_WIN32_KHR
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
delete reinterpret_cast<const safe_VkImportMemoryWin32HandleInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
delete reinterpret_cast<const safe_VkExportMemoryWin32HandleInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
delete reinterpret_cast<const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
delete reinterpret_cast<const safe_VkExportSemaphoreWin32HandleInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
delete reinterpret_cast<const safe_VkD3D12FenceSubmitInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
delete reinterpret_cast<const safe_VkExportFenceWin32HandleInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
delete reinterpret_cast<const safe_VkImportMemoryWin32HandleInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
delete reinterpret_cast<const safe_VkExportMemoryWin32HandleInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
delete reinterpret_cast<const safe_VkWin32KeyedMutexAcquireReleaseInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
delete reinterpret_cast<const safe_VkSurfaceFullScreenExclusiveInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
delete reinterpret_cast<const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(header);
break;
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
delete reinterpret_cast<const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT *>(header);
break;
#endif // VK_USE_PLATFORM_WIN32_KHR
default: // Encountered an unknown sType
// If sType is in custom list, free custom struct memory and clean up
for (auto item : custom_stype_info) {
if (item.first == header->sType) {
if (header->pNext) {
FreePnextChain(header->pNext);
}
free(const_cast<void *>(pNext));
pNext = nullptr;
}
}
if (pNext) {
FreePnextChain(header->pNext);
}
break;
}
}