| // *** THIS FILE IS GENERATED - DO NOT EDIT *** |
| // See helper_file_generator.py for modifications |
| |
| |
| /*************************************************************************** |
| * |
| * Copyright (c) 2015-2020 The Khronos Group Inc. |
| * Copyright (c) 2015-2020 Valve Corporation |
| * Copyright (c) 2015-2020 LunarG, Inc. |
| * Copyright (c) 2015-2020 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 <vulkan/vk_layer.h> |
| |
| |
| 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() : |
| 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 (©_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() : |
| 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 (©_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_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 (©_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_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() : |
| 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 (©_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() : |
| 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(©_src.pQueueCreateInfos[i]); |
| } |
| } |
| if (copy_src.pEnabledFeatures) { |
| pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src.pEnabledFeatures); |
| } |
| } |
| |
| safe_VkDeviceCreateInfo& safe_VkDeviceCreateInfo::operator=(const safe_VkDeviceCreateInfo& copy_src) |
| { |
| if (©_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(©_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(©_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() : |
| 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 (©_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_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() : |
| 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 (©_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_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() : |
| 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 (©_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_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 (©_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 (©_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 (©_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() : |
| 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(©_src.pBufferBinds[i]); |
| } |
| } |
| if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) { |
| pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount]; |
| for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) { |
| pImageOpaqueBinds[i].initialize(©_src.pImageOpaqueBinds[i]); |
| } |
| } |
| if (imageBindCount && copy_src.pImageBinds) { |
| pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount]; |
| for (uint32_t i = 0; i < imageBindCount; ++i) { |
| pImageBinds[i].initialize(©_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 (©_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(©_src.pBufferBinds[i]); |
| } |
| } |
| if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) { |
| pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount]; |
| for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) { |
| pImageOpaqueBinds[i].initialize(©_src.pImageOpaqueBinds[i]); |
| } |
| } |
| if (imageBindCount && copy_src.pImageBinds) { |
| pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount]; |
| for (uint32_t i = 0; i < imageBindCount; ++i) { |
| pImageBinds[i].initialize(©_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(©_src->pBufferBinds[i]); |
| } |
| } |
| if (imageOpaqueBindCount && copy_src->pImageOpaqueBinds) { |
| pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount]; |
| for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) { |
| pImageOpaqueBinds[i].initialize(©_src->pImageOpaqueBinds[i]); |
| } |
| } |
| if (imageBindCount && copy_src->pImageBinds) { |
| pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount]; |
| for (uint32_t i = 0; i < imageBindCount; ++i) { |
| pImageBinds[i].initialize(©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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->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() : |
| 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.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 (©_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.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->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->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() : |
| 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 (©_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->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() : |
| 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.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 (©_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.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->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->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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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 (©_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() : |
| 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 (©_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_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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(©_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 (©_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(©_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(©_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_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() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& copy_src) |
| { |
| sType = copy_src.sType; |
| flags = copy_src.flags; |
| stage.initialize(©_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 (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| flags = copy_src.flags; |
| stage.initialize(©_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(©_src->stage); |
| layout = copy_src->layout; |
| basePipelineHandle = copy_src->basePipelineHandle; |
| basePipelineIndex = copy_src->basePipelineIndex; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| |
| 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() : |
| 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 (©_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() : |
| 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 (©_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_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 (©_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() : |
| 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(©_src.pBindings[i]); |
| } |
| } |
| } |
| |
| safe_VkDescriptorSetLayoutCreateInfo& safe_VkDescriptorSetLayoutCreateInfo::operator=(const safe_VkDescriptorSetLayoutCreateInfo& copy_src) |
| { |
| if (©_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(©_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(©_src->pBindings[i]); |
| } |
| } |
| } |
| |
| 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() : |
| 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 (©_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() : |
| 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 (©_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_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() : |
| 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 (©_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_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() : |
| 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 (©_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_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() : |
| 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 (©_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 (©_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() : |
| 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(©_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 (©_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(©_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(©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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_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() : |
| 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 (©_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_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() : |
| 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 (©_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() : |
| 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 (©_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_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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(©_src.pInputAttachments[i]); |
| } |
| } |
| if (colorAttachmentCount && copy_src.pColorAttachments) { |
| pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; |
| for (uint32_t i = 0; i < colorAttachmentCount; ++i) { |
| pColorAttachments[i].initialize(©_src.pColorAttachments[i]); |
| } |
| } |
| if (colorAttachmentCount && copy_src.pResolveAttachments) { |
| pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; |
| for (uint32_t i = 0; i < colorAttachmentCount; ++i) { |
| pResolveAttachments[i].initialize(©_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 (©_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(©_src.pInputAttachments[i]); |
| } |
| } |
| if (colorAttachmentCount && copy_src.pColorAttachments) { |
| pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; |
| for (uint32_t i = 0; i < colorAttachmentCount; ++i) { |
| pColorAttachments[i].initialize(©_src.pColorAttachments[i]); |
| } |
| } |
| if (colorAttachmentCount && copy_src.pResolveAttachments) { |
| pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; |
| for (uint32_t i = 0; i < colorAttachmentCount; ++i) { |
| pResolveAttachments[i].initialize(©_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(©_src->pInputAttachments[i]); |
| } |
| } |
| if (colorAttachmentCount && copy_src->pColorAttachments) { |
| pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; |
| for (uint32_t i = 0; i < colorAttachmentCount; ++i) { |
| pColorAttachments[i].initialize(©_src->pColorAttachments[i]); |
| } |
| } |
| if (colorAttachmentCount && copy_src->pResolveAttachments) { |
| pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; |
| for (uint32_t i = 0; i < colorAttachmentCount; ++i) { |
| pResolveAttachments[i].initialize(©_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() : |
| 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 (©_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() : |
| 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(©_src.pAttachments[i]); |
| } |
| } |
| if (subpassCount && copy_src.pSubpasses) { |
| pSubpasses = new safe_VkSubpassDescription2[subpassCount]; |
| for (uint32_t i = 0; i < subpassCount; ++i) { |
| pSubpasses[i].initialize(©_src.pSubpasses[i]); |
| } |
| } |
| if (dependencyCount && copy_src.pDependencies) { |
| pDependencies = new safe_VkSubpassDependency2[dependencyCount]; |
| for (uint32_t i = 0; i < dependencyCount; ++i) { |
| pDependencies[i].initialize(©_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 (©_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(©_src.pAttachments[i]); |
| } |
| } |
| if (subpassCount && copy_src.pSubpasses) { |
| pSubpasses = new safe_VkSubpassDescription2[subpassCount]; |
| for (uint32_t i = 0; i < subpassCount; ++i) { |
| pSubpasses[i].initialize(©_src.pSubpasses[i]); |
| } |
| } |
| if (dependencyCount && copy_src.pDependencies) { |
| pDependencies = new safe_VkSubpassDependency2[dependencyCount]; |
| for (uint32_t i = 0; i < dependencyCount; ++i) { |
| pDependencies[i].initialize(©_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(©_src->pAttachments[i]); |
| } |
| } |
| if (subpassCount && copy_src->pSubpasses) { |
| pSubpasses = new safe_VkSubpassDescription2[subpassCount]; |
| for (uint32_t i = 0; i < subpassCount; ++i) { |
| pSubpasses[i].initialize(©_src->pSubpasses[i]); |
| } |
| } |
| if (dependencyCount && copy_src->pDependencies) { |
| pDependencies = new safe_VkSubpassDependency2[dependencyCount]; |
| for (uint32_t i = 0; i < dependencyCount; ++i) { |
| pDependencies[i].initialize(©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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(©_src.pAttachmentImageInfos[i]); |
| } |
| } |
| } |
| |
| safe_VkFramebufferAttachmentsCreateInfo& safe_VkFramebufferAttachmentsCreateInfo::operator=(const safe_VkFramebufferAttachmentsCreateInfo& copy_src) |
| { |
| if (©_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(©_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(©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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->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() : |
| 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.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 (©_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.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->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->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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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_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 (©_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_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() : |
| 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 (©_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_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() : |
| 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 (©_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() : |
| 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 (©_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_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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 (©_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() : |
| 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(©_src.pRegions[i]); |
| } |
| } |
| } |
| |
| safe_VkPresentRegionsKHR& safe_VkPresentRegionsKHR::operator=(const safe_VkPresentRegionsKHR& copy_src) |
| { |
| if (©_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(©_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(©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src) |
| { |
| sType = copy_src.sType; |
| displayProperties.initialize(©_src.displayProperties); |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkDisplayProperties2KHR& safe_VkDisplayProperties2KHR::operator=(const safe_VkDisplayProperties2KHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| displayProperties.initialize(©_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(©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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); |
| } |
| |
| 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() : |
| 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 (©_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_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct) : |
| sType(in_struct->sType), |
| supportsProtected(in_struct->supportsProtected) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR() : |
| 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 (©_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); |
| } |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkDeferredOperationInfoKHR::safe_VkDeferredOperationInfoKHR(const VkDeferredOperationInfoKHR* in_struct) : |
| sType(in_struct->sType), |
| operationHandle(in_struct->operationHandle) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkDeferredOperationInfoKHR::safe_VkDeferredOperationInfoKHR() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkDeferredOperationInfoKHR::safe_VkDeferredOperationInfoKHR(const safe_VkDeferredOperationInfoKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| operationHandle = copy_src.operationHandle; |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkDeferredOperationInfoKHR& safe_VkDeferredOperationInfoKHR::operator=(const safe_VkDeferredOperationInfoKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| operationHandle = copy_src.operationHandle; |
| pNext = SafePnextCopy(copy_src.pNext); |
| |
| return *this; |
| } |
| |
| safe_VkDeferredOperationInfoKHR::~safe_VkDeferredOperationInfoKHR() |
| { |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkDeferredOperationInfoKHR::initialize(const VkDeferredOperationInfoKHR* in_struct) |
| { |
| sType = in_struct->sType; |
| operationHandle = in_struct->operationHandle; |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| void safe_VkDeferredOperationInfoKHR::initialize(const safe_VkDeferredOperationInfoKHR* copy_src) |
| { |
| sType = copy_src->sType; |
| operationHandle = copy_src->operationHandle; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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]; |
| } |
| } |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| 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 (©_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]; |
| } |
| } |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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); |
| } |
| |
| 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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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_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() : |
| 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 (©_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_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() : |
| 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 (©_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); |
| } |
| |
| 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() : |
| 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 (©_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_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() : |
| 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(©_src.pQueueLabels[i]); |
| } |
| } |
| if (cmdBufLabelCount && copy_src.pCmdBufLabels) { |
| pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount]; |
| for (uint32_t i = 0; i < cmdBufLabelCount; ++i) { |
| pCmdBufLabels[i].initialize(©_src.pCmdBufLabels[i]); |
| } |
| } |
| if (objectCount && copy_src.pObjects) { |
| pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount]; |
| for (uint32_t i = 0; i < objectCount; ++i) { |
| pObjects[i].initialize(©_src.pObjects[i]); |
| } |
| } |
| } |
| |
| safe_VkDebugUtilsMessengerCallbackDataEXT& safe_VkDebugUtilsMessengerCallbackDataEXT::operator=(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src) |
| { |
| if (©_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(©_src.pQueueLabels[i]); |
| } |
| } |
| if (cmdBufLabelCount && copy_src.pCmdBufLabels) { |
| pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount]; |
| for (uint32_t i = 0; i < cmdBufLabelCount; ++i) { |
| pCmdBufLabels[i].initialize(©_src.pCmdBufLabels[i]); |
| } |
| } |
| if (objectCount && copy_src.pObjects) { |
| pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount]; |
| for (uint32_t i = 0; i < objectCount; ++i) { |
| pObjects[i].initialize(©_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(©_src->pQueueLabels[i]); |
| } |
| } |
| if (cmdBufLabelCount && copy_src->pCmdBufLabels) { |
| pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount]; |
| for (uint32_t i = 0; i < cmdBufLabelCount; ++i) { |
| pCmdBufLabels[i].initialize(©_src->pCmdBufLabels[i]); |
| } |
| } |
| if (objectCount && copy_src->pObjects) { |
| pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount]; |
| for (uint32_t i = 0; i < objectCount; ++i) { |
| pObjects[i].initialize(©_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() : |
| 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 (©_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); |
| } |
| #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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src) |
| { |
| sType = copy_src.sType; |
| sampleLocationsEnable = copy_src.sampleLocationsEnable; |
| sampleLocationsInfo.initialize(©_src.sampleLocationsInfo); |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkPipelineSampleLocationsStateCreateInfoEXT& safe_VkPipelineSampleLocationsStateCreateInfoEXT::operator=(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| sampleLocationsEnable = copy_src.sampleLocationsEnable; |
| sampleLocationsInfo.initialize(©_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(©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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->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() : |
| 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.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 (©_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.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->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->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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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 (©_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() : |
| 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(©_src.pShadingRatePalettes[i]); |
| } |
| } |
| } |
| |
| safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::operator=(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src) |
| { |
| if (©_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(©_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(©_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() : |
| 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 (©_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() : |
| 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 (©_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 (©_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() : |
| 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(©_src.pCustomSampleOrders[i]); |
| } |
| } |
| } |
| |
| safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src) |
| { |
| if (©_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(©_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(©_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() : |
| 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 (©_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() : |
| 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(©_src.pStages[i]); |
| } |
| } |
| if (groupCount && copy_src.pGroups) { |
| pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount]; |
| for (uint32_t i = 0; i < groupCount; ++i) { |
| pGroups[i].initialize(©_src.pGroups[i]); |
| } |
| } |
| } |
| |
| safe_VkRayTracingPipelineCreateInfoNV& safe_VkRayTracingPipelineCreateInfoNV::operator=(const safe_VkRayTracingPipelineCreateInfoNV& copy_src) |
| { |
| if (©_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(©_src.pStages[i]); |
| } |
| } |
| if (groupCount && copy_src.pGroups) { |
| pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount]; |
| for (uint32_t i = 0; i < groupCount; ++i) { |
| pGroups[i].initialize(©_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(©_src->pStages[i]); |
| } |
| } |
| if (groupCount && copy_src->pGroups) { |
| pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount]; |
| for (uint32_t i = 0; i < groupCount; ++i) { |
| pGroups[i].initialize(©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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(©_src.pGeometries[i]); |
| } |
| } |
| } |
| |
| safe_VkAccelerationStructureInfoNV& safe_VkAccelerationStructureInfoNV::operator=(const safe_VkAccelerationStructureInfoNV& copy_src) |
| { |
| if (©_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(©_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(©_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() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV(const safe_VkAccelerationStructureCreateInfoNV& copy_src) |
| { |
| sType = copy_src.sType; |
| compactedSize = copy_src.compactedSize; |
| info.initialize(©_src.info); |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkAccelerationStructureCreateInfoNV& safe_VkAccelerationStructureCreateInfoNV::operator=(const safe_VkAccelerationStructureCreateInfoNV& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| compactedSize = copy_src.compactedSize; |
| info.initialize(©_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(©_src->info); |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| |
| safe_VkBindAccelerationStructureMemoryInfoKHR::safe_VkBindAccelerationStructureMemoryInfoKHR(const VkBindAccelerationStructureMemoryInfoKHR* 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_VkBindAccelerationStructureMemoryInfoKHR::safe_VkBindAccelerationStructureMemoryInfoKHR() : |
| pNext(nullptr), |
| pDeviceIndices(nullptr) |
| {} |
| |
| safe_VkBindAccelerationStructureMemoryInfoKHR::safe_VkBindAccelerationStructureMemoryInfoKHR(const safe_VkBindAccelerationStructureMemoryInfoKHR& 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_VkBindAccelerationStructureMemoryInfoKHR& safe_VkBindAccelerationStructureMemoryInfoKHR::operator=(const safe_VkBindAccelerationStructureMemoryInfoKHR& copy_src) |
| { |
| if (©_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_VkBindAccelerationStructureMemoryInfoKHR::~safe_VkBindAccelerationStructureMemoryInfoKHR() |
| { |
| if (pDeviceIndices) |
| delete[] pDeviceIndices; |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkBindAccelerationStructureMemoryInfoKHR::initialize(const VkBindAccelerationStructureMemoryInfoKHR* 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_VkBindAccelerationStructureMemoryInfoKHR::initialize(const safe_VkBindAccelerationStructureMemoryInfoKHR* 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_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() : |
| 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 (©_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_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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); |
| } |
| |
| 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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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); |
| } |
| #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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct) : |
| sType(in_struct->sType), |
| indexTypeUint8(in_struct->indexTypeUint8) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT() : |
| 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 (©_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_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct) : |
| sType(in_struct->sType), |
| shaderDemoteToHelperInvocation(in_struct->shaderDemoteToHelperInvocation) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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(©_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 (©_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(©_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(©_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() : |
| 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(©_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 (©_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(©_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(©_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() : |
| 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 (©_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() : |
| 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(©_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 (©_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(©_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(©_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() : |
| 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 (©_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() : |
| 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 (©_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_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct) : |
| sType(in_struct->sType), |
| texelBufferAlignment(in_struct->texelBufferAlignment) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* in_struct) : |
| sType(in_struct->sType), |
| pipelineCreationCacheControl(in_struct->pipelineCreationCacheControl) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT::safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT() : |
| 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 (©_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() : |
| 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 (©_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() : |
| 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 (©_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); |
| } |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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 (©_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; |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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 (©_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; |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| 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 (©_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); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct) : |
| sType(in_struct->sType), |
| maxPayloadSize(in_struct->maxPayloadSize), |
| maxAttributeSize(in_struct->maxAttributeSize), |
| maxCallableSize(in_struct->maxCallableSize) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| maxPayloadSize = copy_src.maxPayloadSize; |
| maxAttributeSize = copy_src.maxAttributeSize; |
| maxCallableSize = copy_src.maxCallableSize; |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkRayTracingPipelineInterfaceCreateInfoKHR& safe_VkRayTracingPipelineInterfaceCreateInfoKHR::operator=(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| maxPayloadSize = copy_src.maxPayloadSize; |
| maxAttributeSize = copy_src.maxAttributeSize; |
| maxCallableSize = copy_src.maxCallableSize; |
| 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; |
| maxPayloadSize = in_struct->maxPayloadSize; |
| maxAttributeSize = in_struct->maxAttributeSize; |
| maxCallableSize = in_struct->maxCallableSize; |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR* copy_src) |
| { |
| sType = copy_src->sType; |
| maxPayloadSize = copy_src->maxPayloadSize; |
| maxAttributeSize = copy_src->maxAttributeSize; |
| maxCallableSize = copy_src->maxCallableSize; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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), |
| maxRecursionDepth(in_struct->maxRecursionDepth), |
| libraries(&in_struct->libraries), |
| pLibraryInterface(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->pLibraryInterface) |
| pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface); |
| } |
| |
| safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR() : |
| pNext(nullptr), |
| pStages(nullptr), |
| pGroups(nullptr), |
| pLibraryInterface(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; |
| maxRecursionDepth = copy_src.maxRecursionDepth; |
| libraries.initialize(©_src.libraries); |
| pLibraryInterface = 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(©_src.pStages[i]); |
| } |
| } |
| if (groupCount && copy_src.pGroups) { |
| pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; |
| for (uint32_t i = 0; i < groupCount; ++i) { |
| pGroups[i].initialize(©_src.pGroups[i]); |
| } |
| } |
| if (copy_src.pLibraryInterface) |
| pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface); |
| } |
| |
| safe_VkRayTracingPipelineCreateInfoKHR& safe_VkRayTracingPipelineCreateInfoKHR::operator=(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pStages) |
| delete[] pStages; |
| if (pGroups) |
| delete[] pGroups; |
| if (pLibraryInterface) |
| delete pLibraryInterface; |
| 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; |
| libraries.initialize(©_src.libraries); |
| pLibraryInterface = 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(©_src.pStages[i]); |
| } |
| } |
| if (groupCount && copy_src.pGroups) { |
| pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; |
| for (uint32_t i = 0; i < groupCount; ++i) { |
| pGroups[i].initialize(©_src.pGroups[i]); |
| } |
| } |
| if (copy_src.pLibraryInterface) |
| pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface); |
| |
| return *this; |
| } |
| |
| safe_VkRayTracingPipelineCreateInfoKHR::~safe_VkRayTracingPipelineCreateInfoKHR() |
| { |
| if (pStages) |
| delete[] pStages; |
| if (pGroups) |
| delete[] pGroups; |
| if (pLibraryInterface) |
| delete pLibraryInterface; |
| 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; |
| maxRecursionDepth = in_struct->maxRecursionDepth; |
| libraries.initialize(&in_struct->libraries); |
| pLibraryInterface = 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->pLibraryInterface) |
| pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface); |
| } |
| |
| 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; |
| maxRecursionDepth = copy_src->maxRecursionDepth; |
| libraries.initialize(©_src->libraries); |
| pLibraryInterface = 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(©_src->pStages[i]); |
| } |
| } |
| if (groupCount && copy_src->pGroups) { |
| pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; |
| for (uint32_t i = 0; i < groupCount; ++i) { |
| pGroups[i].initialize(©_src->pGroups[i]); |
| } |
| } |
| if (copy_src->pLibraryInterface) |
| pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src->pLibraryInterface); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct) : |
| sType(in_struct->sType), |
| vertexFormat(in_struct->vertexFormat), |
| vertexData(&in_struct->vertexData), |
| vertexStride(in_struct->vertexStride), |
| indexType(in_struct->indexType), |
| indexData(&in_struct->indexData), |
| transformData(&in_struct->transformData) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| vertexFormat = copy_src.vertexFormat; |
| vertexData.initialize(©_src.vertexData); |
| vertexStride = copy_src.vertexStride; |
| indexType = copy_src.indexType; |
| indexData.initialize(©_src.indexData); |
| transformData.initialize(©_src.transformData); |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkAccelerationStructureGeometryTrianglesDataKHR& safe_VkAccelerationStructureGeometryTrianglesDataKHR::operator=(const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| vertexFormat = copy_src.vertexFormat; |
| vertexData.initialize(©_src.vertexData); |
| vertexStride = copy_src.vertexStride; |
| indexType = copy_src.indexType; |
| indexData.initialize(©_src.indexData); |
| transformData.initialize(©_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; |
| 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(©_src->vertexData); |
| vertexStride = copy_src->vertexStride; |
| indexType = copy_src->indexType; |
| indexData.initialize(©_src->indexData); |
| transformData.initialize(©_src->transformData); |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| data.initialize(©_src.data); |
| stride = copy_src.stride; |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkAccelerationStructureGeometryAabbsDataKHR& safe_VkAccelerationStructureGeometryAabbsDataKHR::operator=(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| data.initialize(©_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(©_src->data); |
| stride = copy_src->stride; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR(const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| arrayOfPointers = copy_src.arrayOfPointers; |
| data.initialize(©_src.data); |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkAccelerationStructureGeometryInstancesDataKHR& safe_VkAccelerationStructureGeometryInstancesDataKHR::operator=(const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| arrayOfPointers = copy_src.arrayOfPointers; |
| data.initialize(©_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(©_src->data); |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| 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 (©_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); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct) : |
| sType(in_struct->sType), |
| type(in_struct->type), |
| flags(in_struct->flags), |
| update(in_struct->update), |
| srcAccelerationStructure(in_struct->srcAccelerationStructure), |
| dstAccelerationStructure(in_struct->dstAccelerationStructure), |
| geometryArrayOfPointers(in_struct->geometryArrayOfPointers), |
| geometryCount(in_struct->geometryCount), |
| ppGeometries(nullptr), |
| scratchData(&in_struct->scratchData) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| if (geometryCount && in_struct->ppGeometries) { |
| if (geometryArrayOfPointers) { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount]; |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(in_struct->ppGeometries[i]); |
| } |
| } else { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *(new safe_VkAccelerationStructureGeometryKHR[geometryCount]); |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| (*ppGeometries)[i] = safe_VkAccelerationStructureGeometryKHR(&(*in_struct->ppGeometries)[i]); |
| } |
| } |
| } |
| } |
| |
| safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR() : |
| pNext(nullptr), |
| ppGeometries(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| type = copy_src.type; |
| flags = copy_src.flags; |
| update = copy_src.update; |
| srcAccelerationStructure = copy_src.srcAccelerationStructure; |
| dstAccelerationStructure = copy_src.dstAccelerationStructure; |
| geometryArrayOfPointers = copy_src.geometryArrayOfPointers; |
| geometryCount = copy_src.geometryCount; |
| ppGeometries = nullptr; |
| scratchData.initialize(©_src.scratchData); |
| if (geometryCount && copy_src.ppGeometries) { |
| if (geometryArrayOfPointers) { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount]; |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]); |
| } |
| } else { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *(new safe_VkAccelerationStructureGeometryKHR[geometryCount]); |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| (*ppGeometries)[i] = safe_VkAccelerationStructureGeometryKHR((*copy_src.ppGeometries)[i]); |
| } |
| } |
| } |
| } |
| |
| safe_VkAccelerationStructureBuildGeometryInfoKHR& safe_VkAccelerationStructureBuildGeometryInfoKHR::operator=(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (ppGeometries) { |
| if (geometryArrayOfPointers) { |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| delete ppGeometries[i]; |
| } |
| delete[] ppGeometries; |
| } else { |
| delete[] *ppGeometries; |
| delete ppGeometries; |
| } |
| } |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| type = copy_src.type; |
| flags = copy_src.flags; |
| update = copy_src.update; |
| srcAccelerationStructure = copy_src.srcAccelerationStructure; |
| dstAccelerationStructure = copy_src.dstAccelerationStructure; |
| geometryArrayOfPointers = copy_src.geometryArrayOfPointers; |
| geometryCount = copy_src.geometryCount; |
| ppGeometries = nullptr; |
| scratchData.initialize(©_src.scratchData); |
| if (geometryCount && copy_src.ppGeometries) { |
| if (geometryArrayOfPointers) { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount]; |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]); |
| } |
| } else { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *(new safe_VkAccelerationStructureGeometryKHR[geometryCount]); |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| (*ppGeometries)[i] = safe_VkAccelerationStructureGeometryKHR((*copy_src.ppGeometries)[i]); |
| } |
| } |
| } |
| |
| return *this; |
| } |
| |
| safe_VkAccelerationStructureBuildGeometryInfoKHR::~safe_VkAccelerationStructureBuildGeometryInfoKHR() |
| { |
| if (ppGeometries) { |
| if (geometryArrayOfPointers) { |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| delete ppGeometries[i]; |
| } |
| delete[] ppGeometries; |
| } else { |
| delete[] *ppGeometries; |
| delete ppGeometries; |
| } |
| } |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct) |
| { |
| sType = in_struct->sType; |
| type = in_struct->type; |
| flags = in_struct->flags; |
| update = in_struct->update; |
| srcAccelerationStructure = in_struct->srcAccelerationStructure; |
| dstAccelerationStructure = in_struct->dstAccelerationStructure; |
| geometryArrayOfPointers = in_struct->geometryArrayOfPointers; |
| geometryCount = in_struct->geometryCount; |
| ppGeometries = nullptr; |
| scratchData.initialize(&in_struct->scratchData); |
| pNext = SafePnextCopy(in_struct->pNext); |
| if (geometryCount && in_struct->ppGeometries) { |
| if (geometryArrayOfPointers) { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount]; |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(in_struct->ppGeometries[i]); |
| } |
| } else { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *(new safe_VkAccelerationStructureGeometryKHR[geometryCount]); |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| (*ppGeometries)[i] = safe_VkAccelerationStructureGeometryKHR(&(*in_struct->ppGeometries)[i]); |
| } |
| } |
| } |
| } |
| |
| void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const safe_VkAccelerationStructureBuildGeometryInfoKHR* copy_src) |
| { |
| sType = copy_src->sType; |
| type = copy_src->type; |
| flags = copy_src->flags; |
| update = copy_src->update; |
| srcAccelerationStructure = copy_src->srcAccelerationStructure; |
| dstAccelerationStructure = copy_src->dstAccelerationStructure; |
| geometryArrayOfPointers = copy_src->geometryArrayOfPointers; |
| geometryCount = copy_src->geometryCount; |
| ppGeometries = nullptr; |
| scratchData.initialize(©_src->scratchData); |
| if (geometryCount && copy_src->ppGeometries) { |
| if (geometryArrayOfPointers) { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *[geometryCount]; |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src->ppGeometries[i]); |
| } |
| } else { |
| ppGeometries = new safe_VkAccelerationStructureGeometryKHR *(new safe_VkAccelerationStructureGeometryKHR[geometryCount]); |
| for (uint32_t i = 0; i < geometryCount; ++i) { |
| (*ppGeometries)[i] = safe_VkAccelerationStructureGeometryKHR((*copy_src->ppGeometries)[i]); |
| } |
| } |
| } |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkAccelerationStructureCreateGeometryTypeInfoKHR::safe_VkAccelerationStructureCreateGeometryTypeInfoKHR(const VkAccelerationStructureCreateGeometryTypeInfoKHR* in_struct) : |
| sType(in_struct->sType), |
| geometryType(in_struct->geometryType), |
| maxPrimitiveCount(in_struct->maxPrimitiveCount), |
| indexType(in_struct->indexType), |
| maxVertexCount(in_struct->maxVertexCount), |
| vertexFormat(in_struct->vertexFormat), |
| allowsTransforms(in_struct->allowsTransforms) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkAccelerationStructureCreateGeometryTypeInfoKHR::safe_VkAccelerationStructureCreateGeometryTypeInfoKHR() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureCreateGeometryTypeInfoKHR::safe_VkAccelerationStructureCreateGeometryTypeInfoKHR(const safe_VkAccelerationStructureCreateGeometryTypeInfoKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| geometryType = copy_src.geometryType; |
| maxPrimitiveCount = copy_src.maxPrimitiveCount; |
| indexType = copy_src.indexType; |
| maxVertexCount = copy_src.maxVertexCount; |
| vertexFormat = copy_src.vertexFormat; |
| allowsTransforms = copy_src.allowsTransforms; |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkAccelerationStructureCreateGeometryTypeInfoKHR& safe_VkAccelerationStructureCreateGeometryTypeInfoKHR::operator=(const safe_VkAccelerationStructureCreateGeometryTypeInfoKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| geometryType = copy_src.geometryType; |
| maxPrimitiveCount = copy_src.maxPrimitiveCount; |
| indexType = copy_src.indexType; |
| maxVertexCount = copy_src.maxVertexCount; |
| vertexFormat = copy_src.vertexFormat; |
| allowsTransforms = copy_src.allowsTransforms; |
| pNext = SafePnextCopy(copy_src.pNext); |
| |
| return *this; |
| } |
| |
| safe_VkAccelerationStructureCreateGeometryTypeInfoKHR::~safe_VkAccelerationStructureCreateGeometryTypeInfoKHR() |
| { |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkAccelerationStructureCreateGeometryTypeInfoKHR::initialize(const VkAccelerationStructureCreateGeometryTypeInfoKHR* in_struct) |
| { |
| sType = in_struct->sType; |
| geometryType = in_struct->geometryType; |
| maxPrimitiveCount = in_struct->maxPrimitiveCount; |
| indexType = in_struct->indexType; |
| maxVertexCount = in_struct->maxVertexCount; |
| vertexFormat = in_struct->vertexFormat; |
| allowsTransforms = in_struct->allowsTransforms; |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| void safe_VkAccelerationStructureCreateGeometryTypeInfoKHR::initialize(const safe_VkAccelerationStructureCreateGeometryTypeInfoKHR* copy_src) |
| { |
| sType = copy_src->sType; |
| geometryType = copy_src->geometryType; |
| maxPrimitiveCount = copy_src->maxPrimitiveCount; |
| indexType = copy_src->indexType; |
| maxVertexCount = copy_src->maxVertexCount; |
| vertexFormat = copy_src->vertexFormat; |
| allowsTransforms = copy_src->allowsTransforms; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR* in_struct) : |
| sType(in_struct->sType), |
| compactedSize(in_struct->compactedSize), |
| type(in_struct->type), |
| flags(in_struct->flags), |
| maxGeometryCount(in_struct->maxGeometryCount), |
| pGeometryInfos(nullptr), |
| deviceAddress(in_struct->deviceAddress) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| if (maxGeometryCount && in_struct->pGeometryInfos) { |
| pGeometryInfos = new safe_VkAccelerationStructureCreateGeometryTypeInfoKHR[maxGeometryCount]; |
| for (uint32_t i = 0; i < maxGeometryCount; ++i) { |
| pGeometryInfos[i].initialize(&in_struct->pGeometryInfos[i]); |
| } |
| } |
| } |
| |
| safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR() : |
| pNext(nullptr), |
| pGeometryInfos(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR(const safe_VkAccelerationStructureCreateInfoKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| compactedSize = copy_src.compactedSize; |
| type = copy_src.type; |
| flags = copy_src.flags; |
| maxGeometryCount = copy_src.maxGeometryCount; |
| pGeometryInfos = nullptr; |
| deviceAddress = copy_src.deviceAddress; |
| pNext = SafePnextCopy(copy_src.pNext); |
| if (maxGeometryCount && copy_src.pGeometryInfos) { |
| pGeometryInfos = new safe_VkAccelerationStructureCreateGeometryTypeInfoKHR[maxGeometryCount]; |
| for (uint32_t i = 0; i < maxGeometryCount; ++i) { |
| pGeometryInfos[i].initialize(©_src.pGeometryInfos[i]); |
| } |
| } |
| } |
| |
| safe_VkAccelerationStructureCreateInfoKHR& safe_VkAccelerationStructureCreateInfoKHR::operator=(const safe_VkAccelerationStructureCreateInfoKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pGeometryInfos) |
| delete[] pGeometryInfos; |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| compactedSize = copy_src.compactedSize; |
| type = copy_src.type; |
| flags = copy_src.flags; |
| maxGeometryCount = copy_src.maxGeometryCount; |
| pGeometryInfos = nullptr; |
| deviceAddress = copy_src.deviceAddress; |
| pNext = SafePnextCopy(copy_src.pNext); |
| if (maxGeometryCount && copy_src.pGeometryInfos) { |
| pGeometryInfos = new safe_VkAccelerationStructureCreateGeometryTypeInfoKHR[maxGeometryCount]; |
| for (uint32_t i = 0; i < maxGeometryCount; ++i) { |
| pGeometryInfos[i].initialize(©_src.pGeometryInfos[i]); |
| } |
| } |
| |
| return *this; |
| } |
| |
| safe_VkAccelerationStructureCreateInfoKHR::~safe_VkAccelerationStructureCreateInfoKHR() |
| { |
| if (pGeometryInfos) |
| delete[] pGeometryInfos; |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkAccelerationStructureCreateInfoKHR::initialize(const VkAccelerationStructureCreateInfoKHR* in_struct) |
| { |
| sType = in_struct->sType; |
| compactedSize = in_struct->compactedSize; |
| type = in_struct->type; |
| flags = in_struct->flags; |
| maxGeometryCount = in_struct->maxGeometryCount; |
| pGeometryInfos = nullptr; |
| deviceAddress = in_struct->deviceAddress; |
| pNext = SafePnextCopy(in_struct->pNext); |
| if (maxGeometryCount && in_struct->pGeometryInfos) { |
| pGeometryInfos = new safe_VkAccelerationStructureCreateGeometryTypeInfoKHR[maxGeometryCount]; |
| for (uint32_t i = 0; i < maxGeometryCount; ++i) { |
| pGeometryInfos[i].initialize(&in_struct->pGeometryInfos[i]); |
| } |
| } |
| } |
| |
| void safe_VkAccelerationStructureCreateInfoKHR::initialize(const safe_VkAccelerationStructureCreateInfoKHR* copy_src) |
| { |
| sType = copy_src->sType; |
| compactedSize = copy_src->compactedSize; |
| type = copy_src->type; |
| flags = copy_src->flags; |
| maxGeometryCount = copy_src->maxGeometryCount; |
| pGeometryInfos = nullptr; |
| deviceAddress = copy_src->deviceAddress; |
| pNext = SafePnextCopy(copy_src->pNext); |
| if (maxGeometryCount && copy_src->pGeometryInfos) { |
| pGeometryInfos = new safe_VkAccelerationStructureCreateGeometryTypeInfoKHR[maxGeometryCount]; |
| for (uint32_t i = 0; i < maxGeometryCount; ++i) { |
| pGeometryInfos[i].initialize(©_src->pGeometryInfos[i]); |
| } |
| } |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkAccelerationStructureMemoryRequirementsInfoKHR::safe_VkAccelerationStructureMemoryRequirementsInfoKHR(const VkAccelerationStructureMemoryRequirementsInfoKHR* in_struct) : |
| sType(in_struct->sType), |
| type(in_struct->type), |
| buildType(in_struct->buildType), |
| accelerationStructure(in_struct->accelerationStructure) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkAccelerationStructureMemoryRequirementsInfoKHR::safe_VkAccelerationStructureMemoryRequirementsInfoKHR() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureMemoryRequirementsInfoKHR::safe_VkAccelerationStructureMemoryRequirementsInfoKHR(const safe_VkAccelerationStructureMemoryRequirementsInfoKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| type = copy_src.type; |
| buildType = copy_src.buildType; |
| accelerationStructure = copy_src.accelerationStructure; |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkAccelerationStructureMemoryRequirementsInfoKHR& safe_VkAccelerationStructureMemoryRequirementsInfoKHR::operator=(const safe_VkAccelerationStructureMemoryRequirementsInfoKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| type = copy_src.type; |
| buildType = copy_src.buildType; |
| accelerationStructure = copy_src.accelerationStructure; |
| pNext = SafePnextCopy(copy_src.pNext); |
| |
| return *this; |
| } |
| |
| safe_VkAccelerationStructureMemoryRequirementsInfoKHR::~safe_VkAccelerationStructureMemoryRequirementsInfoKHR() |
| { |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkAccelerationStructureMemoryRequirementsInfoKHR::initialize(const VkAccelerationStructureMemoryRequirementsInfoKHR* in_struct) |
| { |
| sType = in_struct->sType; |
| type = in_struct->type; |
| buildType = in_struct->buildType; |
| accelerationStructure = in_struct->accelerationStructure; |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| void safe_VkAccelerationStructureMemoryRequirementsInfoKHR::initialize(const safe_VkAccelerationStructureMemoryRequirementsInfoKHR* copy_src) |
| { |
| sType = copy_src->sType; |
| type = copy_src->type; |
| buildType = copy_src->buildType; |
| accelerationStructure = copy_src->accelerationStructure; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkPhysicalDeviceRayTracingFeaturesKHR::safe_VkPhysicalDeviceRayTracingFeaturesKHR(const VkPhysicalDeviceRayTracingFeaturesKHR* in_struct) : |
| sType(in_struct->sType), |
| rayTracing(in_struct->rayTracing), |
| rayTracingShaderGroupHandleCaptureReplay(in_struct->rayTracingShaderGroupHandleCaptureReplay), |
| rayTracingShaderGroupHandleCaptureReplayMixed(in_struct->rayTracingShaderGroupHandleCaptureReplayMixed), |
| rayTracingAccelerationStructureCaptureReplay(in_struct->rayTracingAccelerationStructureCaptureReplay), |
| rayTracingIndirectTraceRays(in_struct->rayTracingIndirectTraceRays), |
| rayTracingIndirectAccelerationStructureBuild(in_struct->rayTracingIndirectAccelerationStructureBuild), |
| rayTracingHostAccelerationStructureCommands(in_struct->rayTracingHostAccelerationStructureCommands), |
| rayQuery(in_struct->rayQuery), |
| rayTracingPrimitiveCulling(in_struct->rayTracingPrimitiveCulling) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkPhysicalDeviceRayTracingFeaturesKHR::safe_VkPhysicalDeviceRayTracingFeaturesKHR() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkPhysicalDeviceRayTracingFeaturesKHR::safe_VkPhysicalDeviceRayTracingFeaturesKHR(const safe_VkPhysicalDeviceRayTracingFeaturesKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| rayTracing = copy_src.rayTracing; |
| rayTracingShaderGroupHandleCaptureReplay = copy_src.rayTracingShaderGroupHandleCaptureReplay; |
| rayTracingShaderGroupHandleCaptureReplayMixed = copy_src.rayTracingShaderGroupHandleCaptureReplayMixed; |
| rayTracingAccelerationStructureCaptureReplay = copy_src.rayTracingAccelerationStructureCaptureReplay; |
| rayTracingIndirectTraceRays = copy_src.rayTracingIndirectTraceRays; |
| rayTracingIndirectAccelerationStructureBuild = copy_src.rayTracingIndirectAccelerationStructureBuild; |
| rayTracingHostAccelerationStructureCommands = copy_src.rayTracingHostAccelerationStructureCommands; |
| rayQuery = copy_src.rayQuery; |
| rayTracingPrimitiveCulling = copy_src.rayTracingPrimitiveCulling; |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkPhysicalDeviceRayTracingFeaturesKHR& safe_VkPhysicalDeviceRayTracingFeaturesKHR::operator=(const safe_VkPhysicalDeviceRayTracingFeaturesKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| rayTracing = copy_src.rayTracing; |
| rayTracingShaderGroupHandleCaptureReplay = copy_src.rayTracingShaderGroupHandleCaptureReplay; |
| rayTracingShaderGroupHandleCaptureReplayMixed = copy_src.rayTracingShaderGroupHandleCaptureReplayMixed; |
| rayTracingAccelerationStructureCaptureReplay = copy_src.rayTracingAccelerationStructureCaptureReplay; |
| rayTracingIndirectTraceRays = copy_src.rayTracingIndirectTraceRays; |
| rayTracingIndirectAccelerationStructureBuild = copy_src.rayTracingIndirectAccelerationStructureBuild; |
| rayTracingHostAccelerationStructureCommands = copy_src.rayTracingHostAccelerationStructureCommands; |
| rayQuery = copy_src.rayQuery; |
| rayTracingPrimitiveCulling = copy_src.rayTracingPrimitiveCulling; |
| pNext = SafePnextCopy(copy_src.pNext); |
| |
| return *this; |
| } |
| |
| safe_VkPhysicalDeviceRayTracingFeaturesKHR::~safe_VkPhysicalDeviceRayTracingFeaturesKHR() |
| { |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkPhysicalDeviceRayTracingFeaturesKHR::initialize(const VkPhysicalDeviceRayTracingFeaturesKHR* in_struct) |
| { |
| sType = in_struct->sType; |
| rayTracing = in_struct->rayTracing; |
| rayTracingShaderGroupHandleCaptureReplay = in_struct->rayTracingShaderGroupHandleCaptureReplay; |
| rayTracingShaderGroupHandleCaptureReplayMixed = in_struct->rayTracingShaderGroupHandleCaptureReplayMixed; |
| rayTracingAccelerationStructureCaptureReplay = in_struct->rayTracingAccelerationStructureCaptureReplay; |
| rayTracingIndirectTraceRays = in_struct->rayTracingIndirectTraceRays; |
| rayTracingIndirectAccelerationStructureBuild = in_struct->rayTracingIndirectAccelerationStructureBuild; |
| rayTracingHostAccelerationStructureCommands = in_struct->rayTracingHostAccelerationStructureCommands; |
| rayQuery = in_struct->rayQuery; |
| rayTracingPrimitiveCulling = in_struct->rayTracingPrimitiveCulling; |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| void safe_VkPhysicalDeviceRayTracingFeaturesKHR::initialize(const safe_VkPhysicalDeviceRayTracingFeaturesKHR* copy_src) |
| { |
| sType = copy_src->sType; |
| rayTracing = copy_src->rayTracing; |
| rayTracingShaderGroupHandleCaptureReplay = copy_src->rayTracingShaderGroupHandleCaptureReplay; |
| rayTracingShaderGroupHandleCaptureReplayMixed = copy_src->rayTracingShaderGroupHandleCaptureReplayMixed; |
| rayTracingAccelerationStructureCaptureReplay = copy_src->rayTracingAccelerationStructureCaptureReplay; |
| rayTracingIndirectTraceRays = copy_src->rayTracingIndirectTraceRays; |
| rayTracingIndirectAccelerationStructureBuild = copy_src->rayTracingIndirectAccelerationStructureBuild; |
| rayTracingHostAccelerationStructureCommands = copy_src->rayTracingHostAccelerationStructureCommands; |
| rayQuery = copy_src->rayQuery; |
| rayTracingPrimitiveCulling = copy_src->rayTracingPrimitiveCulling; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkPhysicalDeviceRayTracingPropertiesKHR::safe_VkPhysicalDeviceRayTracingPropertiesKHR(const VkPhysicalDeviceRayTracingPropertiesKHR* 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), |
| maxPrimitiveCount(in_struct->maxPrimitiveCount), |
| maxDescriptorSetAccelerationStructures(in_struct->maxDescriptorSetAccelerationStructures), |
| shaderGroupHandleCaptureReplaySize(in_struct->shaderGroupHandleCaptureReplaySize) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| safe_VkPhysicalDeviceRayTracingPropertiesKHR::safe_VkPhysicalDeviceRayTracingPropertiesKHR() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkPhysicalDeviceRayTracingPropertiesKHR::safe_VkPhysicalDeviceRayTracingPropertiesKHR(const safe_VkPhysicalDeviceRayTracingPropertiesKHR& 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; |
| maxPrimitiveCount = copy_src.maxPrimitiveCount; |
| maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures; |
| shaderGroupHandleCaptureReplaySize = copy_src.shaderGroupHandleCaptureReplaySize; |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkPhysicalDeviceRayTracingPropertiesKHR& safe_VkPhysicalDeviceRayTracingPropertiesKHR::operator=(const safe_VkPhysicalDeviceRayTracingPropertiesKHR& copy_src) |
| { |
| if (©_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; |
| maxPrimitiveCount = copy_src.maxPrimitiveCount; |
| maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures; |
| shaderGroupHandleCaptureReplaySize = copy_src.shaderGroupHandleCaptureReplaySize; |
| pNext = SafePnextCopy(copy_src.pNext); |
| |
| return *this; |
| } |
| |
| safe_VkPhysicalDeviceRayTracingPropertiesKHR::~safe_VkPhysicalDeviceRayTracingPropertiesKHR() |
| { |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkPhysicalDeviceRayTracingPropertiesKHR::initialize(const VkPhysicalDeviceRayTracingPropertiesKHR* 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; |
| maxPrimitiveCount = in_struct->maxPrimitiveCount; |
| maxDescriptorSetAccelerationStructures = in_struct->maxDescriptorSetAccelerationStructures; |
| shaderGroupHandleCaptureReplaySize = in_struct->shaderGroupHandleCaptureReplaySize; |
| pNext = SafePnextCopy(in_struct->pNext); |
| } |
| |
| void safe_VkPhysicalDeviceRayTracingPropertiesKHR::initialize(const safe_VkPhysicalDeviceRayTracingPropertiesKHR* 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; |
| maxPrimitiveCount = copy_src->maxPrimitiveCount; |
| maxDescriptorSetAccelerationStructures = copy_src->maxDescriptorSetAccelerationStructures; |
| shaderGroupHandleCaptureReplaySize = copy_src->shaderGroupHandleCaptureReplaySize; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| 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 (©_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); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| safe_VkAccelerationStructureVersionKHR::safe_VkAccelerationStructureVersionKHR(const VkAccelerationStructureVersionKHR* in_struct) : |
| sType(in_struct->sType), |
| versionData(nullptr) |
| { |
| pNext = SafePnextCopy(in_struct->pNext); |
| if (in_struct->versionData) { |
| versionData = new uint8_t[2*VK_UUID_SIZE]; |
| memcpy ((void *)versionData, (void *)in_struct->versionData, sizeof(uint8_t)*2*VK_UUID_SIZE); |
| } |
| } |
| |
| safe_VkAccelerationStructureVersionKHR::safe_VkAccelerationStructureVersionKHR() : |
| pNext(nullptr), |
| versionData(nullptr) |
| {} |
| |
| safe_VkAccelerationStructureVersionKHR::safe_VkAccelerationStructureVersionKHR(const safe_VkAccelerationStructureVersionKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| versionData = nullptr; |
| pNext = SafePnextCopy(copy_src.pNext); |
| if (copy_src.versionData) { |
| versionData = new uint8_t[2*VK_UUID_SIZE]; |
| memcpy ((void *)versionData, (void *)copy_src.versionData, sizeof(uint8_t)*2*VK_UUID_SIZE); |
| } |
| } |
| |
| safe_VkAccelerationStructureVersionKHR& safe_VkAccelerationStructureVersionKHR::operator=(const safe_VkAccelerationStructureVersionKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (versionData) |
| delete[] versionData; |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| versionData = nullptr; |
| pNext = SafePnextCopy(copy_src.pNext); |
| if (copy_src.versionData) { |
| versionData = new uint8_t[2*VK_UUID_SIZE]; |
| memcpy ((void *)versionData, (void *)copy_src.versionData, sizeof(uint8_t)*2*VK_UUID_SIZE); |
| } |
| |
| return *this; |
| } |
| |
| safe_VkAccelerationStructureVersionKHR::~safe_VkAccelerationStructureVersionKHR() |
| { |
| if (versionData) |
| delete[] versionData; |
| if (pNext) |
| FreePnextChain(pNext); |
| } |
| |
| void safe_VkAccelerationStructureVersionKHR::initialize(const VkAccelerationStructureVersionKHR* in_struct) |
| { |
| sType = in_struct->sType; |
| versionData = nullptr; |
| pNext = SafePnextCopy(in_struct->pNext); |
| if (in_struct->versionData) { |
| versionData = new uint8_t[2*VK_UUID_SIZE]; |
| memcpy ((void *)versionData, (void *)in_struct->versionData, sizeof(uint8_t)*2*VK_UUID_SIZE); |
| } |
| } |
| |
| void safe_VkAccelerationStructureVersionKHR::initialize(const safe_VkAccelerationStructureVersionKHR* copy_src) |
| { |
| sType = copy_src->sType; |
| versionData = nullptr; |
| pNext = SafePnextCopy(copy_src->pNext); |
| if (copy_src->versionData) { |
| versionData = new uint8_t[2*VK_UUID_SIZE]; |
| memcpy ((void *)versionData, (void *)copy_src->versionData, sizeof(uint8_t)*2*VK_UUID_SIZE); |
| } |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| src = copy_src.src; |
| dst.initialize(©_src.dst); |
| mode = copy_src.mode; |
| pNext = SafePnextCopy(copy_src.pNext); |
| } |
| |
| safe_VkCopyAccelerationStructureToMemoryInfoKHR& safe_VkCopyAccelerationStructureToMemoryInfoKHR::operator=(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src) |
| { |
| if (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| src = copy_src.src; |
| dst.initialize(©_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(©_src->dst); |
| mode = copy_src->mode; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| pNext(nullptr) |
| {} |
| |
| safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src) |
| { |
| sType = copy_src.sType; |
| src.initialize(©_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 (©_src == this) return *this; |
| |
| if (pNext) |
| FreePnextChain(pNext); |
| |
| sType = copy_src.sType; |
| src.initialize(©_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(©_src->src); |
| dst = copy_src->dst; |
| mode = copy_src->mode; |
| pNext = SafePnextCopy(copy_src->pNext); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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() : |
| 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 (©_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); |
| } |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| |
| 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_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_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_KHR: |
| safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(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_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_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_INDEX_TYPE_UINT8_FEATURES_EXT: |
| safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(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_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_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; |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| case VK_STRUCTURE_TYPE_DEFERRED_OPERATION_INFO_KHR: |
| safe_pNext = new safe_VkDeferredOperationInfoKHR(reinterpret_cast<const VkDeferredOperationInfoKHR *>(pNext)); |
| break; |
| case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR: |
| safe_pNext = new safe_VkPhysicalDeviceRayTracingFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingFeaturesKHR *>(pNext)); |
| break; |
| case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR: |
| safe_pNext = new safe_VkPhysicalDeviceRayTracingPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesKHR *>(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_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 |
| 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_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_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_KHR: |
| delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureKHR *>(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_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_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_INDEX_TYPE_UINT8_FEATURES_EXT: |
| delete reinterpret_cast<const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(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_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_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; |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| case VK_STRUCTURE_TYPE_DEFERRED_OPERATION_INFO_KHR: |
| delete reinterpret_cast<const safe_VkDeferredOperationInfoKHR *>(header); |
| break; |
| case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR: |
| delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingFeaturesKHR *>(header); |
| break; |
| case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR: |
| delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPropertiesKHR *>(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_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 -- panic, there should be none such in safe chain |
| assert(false); |
| FreePnextChain(header->pNext); |
| break; |
| } |
| } |