Lines Matching refs:src
45 safe_VkApplicationInfo::safe_VkApplicationInfo(const safe_VkApplicationInfo& src)
47 sType = src.sType;
48 pNext = src.pNext;
49 pApplicationName = src.pApplicationName;
50 applicationVersion = src.applicationVersion;
51 pEngineName = src.pEngineName;
52 engineVersion = src.engineVersion;
53 apiVersion = src.apiVersion;
71 void safe_VkApplicationInfo::initialize(const safe_VkApplicationInfo* src)
73 sType = src->sType;
74 pNext = src->pNext;
75 pApplicationName = src->pApplicationName;
76 applicationVersion = src->applicationVersion;
77 pEngineName = src->pEngineName;
78 engineVersion = src->engineVersion;
79 apiVersion = src->apiVersion;
100 safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& src)
102 sType = src.sType;
103 pNext = src.pNext;
104 flags = src.flags;
105 enabledLayerCount = src.enabledLayerCount;
106 ppEnabledLayerNames = src.ppEnabledLayerNames;
107 enabledExtensionCount = src.enabledExtensionCount;
108 ppEnabledExtensionNames = src.ppEnabledExtensionNames;
109 if (src.pApplicationInfo)
110 pApplicationInfo = new safe_VkApplicationInfo(*src.pApplicationInfo);
136 void safe_VkInstanceCreateInfo::initialize(const safe_VkInstanceCreateInfo* src)
138 sType = src->sType;
139 pNext = src->pNext;
140 flags = src->flags;
141 enabledLayerCount = src->enabledLayerCount;
142 ppEnabledLayerNames = src->ppEnabledLayerNames;
143 enabledExtensionCount = src->enabledExtensionCount;
144 ppEnabledExtensionNames = src->ppEnabledExtensionNames;
145 if (src->pApplicationInfo)
146 pApplicationInfo = new safe_VkApplicationInfo(*src->pApplicationInfo);
164 safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& src)
166 pUserData = src.pUserData;
167 pfnAllocation = src.pfnAllocation;
168 pfnReallocation = src.pfnReallocation;
169 pfnFree = src.pfnFree;
170 pfnInternalAllocation = src.pfnInternalAllocation;
171 pfnInternalFree = src.pfnInternalFree;
188 void safe_VkAllocationCallbacks::initialize(const safe_VkAllocationCallbacks* src)
190 pUserData = src->pUserData;
191 pfnAllocation = src->pfnAllocation;
192 pfnReallocation = src->pfnReallocation;
193 pfnFree = src->pfnFree;
194 pfnInternalAllocation = src->pfnInternalAllocation;
195 pfnInternalFree = src->pfnInternalFree;
216 safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& src)
218 sType = src.sType;
219 pNext = src.pNext;
220 flags = src.flags;
221 queueFamilyIndex = src.queueFamilyIndex;
222 queueCount = src.queueCount;
224 if (src.pQueuePriorities) {
225 pQueuePriorities = new float[src.queueCount];
226 memcpy ((void *)pQueuePriorities, (void *)src.pQueuePriorities, sizeof(float)*src.queueCount);
250 void safe_VkDeviceQueueCreateInfo::initialize(const safe_VkDeviceQueueCreateInfo* src)
252 sType = src->sType;
253 pNext = src->pNext;
254 flags = src->flags;
255 queueFamilyIndex = src->queueFamilyIndex;
256 queueCount = src->queueCount;
258 if (src->pQueuePriorities) {
259 pQueuePriorities = new float[src->queueCount];
260 memcpy ((void *)pQueuePriorities, (void *)src->pQueuePriorities, sizeof(float)*src->queueCount);
292 safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& src)
294 sType = src.sType;
295 pNext = src.pNext;
296 flags = src.flags;
297 queueCreateInfoCount = src.queueCreateInfoCount;
299 enabledLayerCount = src.enabledLayerCount;
300 ppEnabledLayerNames = src.ppEnabledLayerNames;
301 enabledExtensionCount = src.enabledExtensionCount;
302 ppEnabledExtensionNames = src.ppEnabledExtensionNames;
304 if (queueCreateInfoCount && src.pQueueCreateInfos) {
307 pQueueCreateInfos[i].initialize(&src.pQueueCreateInfos[i]);
310 if (src.pEnabledFeatures) {
311 pEnabledFeatures = new VkPhysicalDeviceFeatures(*src.pEnabledFeatures);
346 void safe_VkDeviceCreateInfo::initialize(const safe_VkDeviceCreateInfo* src)
348 sType = src->sType;
349 pNext = src->pNext;
350 flags = src->flags;
351 queueCreateInfoCount = src->queueCreateInfoCount;
353 enabledLayerCount = src->enabledLayerCount;
354 ppEnabledLayerNames = src->ppEnabledLayerNames;
355 enabledExtensionCount = src->enabledExtensionCount;
356 ppEnabledExtensionNames = src->ppEnabledExtensionNames;
358 if (queueCreateInfoCount && src->pQueueCreateInfos) {
361 pQueueCreateInfos[i].initialize(&src->pQueueCreateInfos[i]);
364 if (src->pEnabledFeatures) {
365 pEnabledFeatures = new VkPhysicalDeviceFeatures(*src->pEnabledFeatures);
408 safe_VkSubmitInfo::safe_VkSubmitInfo(const safe_VkSubmitInfo& src)
410 sType = src.sType;
411 pNext = src.pNext;
412 waitSemaphoreCount = src.waitSemaphoreCount;
415 commandBufferCount = src.commandBufferCount;
417 signalSemaphoreCount = src.signalSemaphoreCount;
419 if (waitSemaphoreCount && src.pWaitSemaphores) {
422 pWaitSemaphores[i] = src.pWaitSemaphores[i];
425 if (src.pWaitDstStageMask) {
426 pWaitDstStageMask = new VkPipelineStageFlags(*src.pWaitDstStageMask);
428 if (src.pCommandBuffers) {
429 pCommandBuffers = new VkCommandBuffer[src.commandBufferCount];
430 memcpy ((void *)pCommandBuffers, (void *)src.pCommandBuffers, sizeof(VkCommandBuffer)*src.commandBufferCount);
432 if (signalSemaphoreCount && src.pSignalSemaphores) {
435 pSignalSemaphores[i] = src.pSignalSemaphores[i];
484 void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* src)
486 sType = src->sType;
487 pNext = src->pNext;
488 waitSemaphoreCount = src->waitSemaphoreCount;
491 commandBufferCount = src->commandBufferCount;
493 signalSemaphoreCount = src->signalSemaphoreCount;
495 if (waitSemaphoreCount && src->pWaitSemaphores) {
498 pWaitSemaphores[i] = src->pWaitSemaphores[i];
501 if (src->pWaitDstStageMask) {
502 pWaitDstStageMask = new VkPipelineStageFlags(*src->pWaitDstStageMask);
504 if (src->pCommandBuffers) {
505 pCommandBuffers = new VkCommandBuffer[src->commandBufferCount];
506 memcpy ((void *)pCommandBuffers, (void *)src->pCommandBuffers, sizeof(VkCommandBuffer)*src->commandBufferCount);
508 if (signalSemaphoreCount && src->pSignalSemaphores) {
511 pSignalSemaphores[i] = src->pSignalSemaphores[i];
527 safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& src)
529 sType = src.sType;
530 pNext = src.pNext;
531 allocationSize = src.allocationSize;
532 memoryTypeIndex = src.memoryTypeIndex;
547 void safe_VkMemoryAllocateInfo::initialize(const safe_VkMemoryAllocateInfo* src)
549 sType = src->sType;
550 pNext = src->pNext;
551 allocationSize = src->allocationSize;
552 memoryTypeIndex = src->memoryTypeIndex;
567 safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& src)
569 sType = src.sType;
570 pNext = src.pNext;
571 memory = src.memory;
572 offset = src.offset;
573 size = src.size;
589 void safe_VkMappedMemoryRange::initialize(const safe_VkMappedMemoryRange* src)
591 sType = src->sType;
592 pNext = src->pNext;
593 memory = src->memory;
594 offset = src->offset;
595 size = src->size;
615 safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& src)
617 buffer = src.buffer;
618 bindCount = src.bindCount;
620 if (bindCount && src.pBinds) {
623 pBinds[i] = src.pBinds[i];
647 void safe_VkSparseBufferMemoryBindInfo::initialize(const safe_VkSparseBufferMemoryBindInfo* src)
649 buffer = src->buffer;
650 bindCount = src->bindCount;
652 if (bindCount && src->pBinds) {
655 pBinds[i] = src->pBinds[i];
677 safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& src)
679 image = src.image;
680 bindCount = src.bindCount;
682 if (bindCount && src.pBinds) {
685 pBinds[i] = src.pBinds[i];
709 void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* src)
711 image = src->image;
712 bindCount = src->bindCount;
714 if (bindCount && src->pBinds) {
717 pBinds[i] = src->pBinds[i];
739 safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& src)
741 image = src.image;
742 bindCount = src.bindCount;
744 if (bindCount && src.pBinds) {
747 pBinds[i] = src.pBinds[i];
771 void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemoryBindInfo* src)
773 image = src->image;
774 bindCount = src->bindCount;
776 if (bindCount && src->pBinds) {
779 pBinds[i] = src->pBinds[i];
838 safe_VkBindSparseInfo::safe_VkBindSparseInfo(const safe_VkBindSparseInfo& src)
840 sType = src.sType;
841 pNext = src.pNext;
842 waitSemaphoreCount = src.waitSemaphoreCount;
844 bufferBindCount = src.bufferBindCount;
846 imageOpaqueBindCount = src.imageOpaqueBindCount;
848 imageBindCount = src.imageBindCount;
850 signalSemaphoreCount = src.signalSemaphoreCount;
852 if (waitSemaphoreCount && src.pWaitSemaphores) {
855 pWaitSemaphores[i] = src.pWaitSemaphores[i];
858 if (bufferBindCount && src.pBufferBinds) {
861 pBufferBinds[i].initialize(&src.pBufferBinds[i]);
864 if (imageOpaqueBindCount && src.pImageOpaqueBinds) {
867 pImageOpaqueBinds[i].initialize(&src.pImageOpaqueBinds[i]);
870 if (imageBindCount && src.pImageBinds) {
873 pImageBinds[i].initialize(&src.pImageBinds[i]);
876 if (signalSemaphoreCount && src.pSignalSemaphores) {
879 pSignalSemaphores[i] = src.pSignalSemaphores[i];
944 void safe_VkBindSparseInfo::initialize(const safe_VkBindSparseInfo* src)
946 sType = src->sType;
947 pNext = src->pNext;
948 waitSemaphoreCount = src->waitSemaphoreCount;
950 bufferBindCount = src->bufferBindCount;
952 imageOpaqueBindCount = src->imageOpaqueBindCount;
954 imageBindCount = src->imageBindCount;
956 signalSemaphoreCount = src->signalSemaphoreCount;
958 if (waitSemaphoreCount && src->pWaitSemaphores) {
961 pWaitSemaphores[i] = src->pWaitSemaphores[i];
964 if (bufferBindCount && src->pBufferBinds) {
967 pBufferBinds[i].initialize(&src->pBufferBinds[i]);
970 if (imageOpaqueBindCount && src->pImageOpaqueBinds) {
973 pImageOpaqueBinds[i].initialize(&src->pImageOpaqueBinds[i]);
976 if (imageBindCount && src->pImageBinds) {
979 pImageBinds[i].initialize(&src->pImageBinds[i]);
982 if (signalSemaphoreCount && src->pSignalSemaphores) {
985 pSignalSemaphores[i] = src->pSignalSemaphores[i];
1000 safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& src)
1002 sType = src.sType;
1003 pNext = src.pNext;
1004 flags = src.flags;
1018 void safe_VkFenceCreateInfo::initialize(const safe_VkFenceCreateInfo* src)
1020 sType = src->sType;
1021 pNext = src->pNext;
1022 flags = src->flags;
1035 safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& src)
1037 sType = src.sType;
1038 pNext = src.pNext;
1039 flags = src.flags;
1053 void safe_VkSemaphoreCreateInfo::initialize(const safe_VkSemaphoreCreateInfo* src)
1055 sType = src->sType;
1056 pNext = src->pNext;
1057 flags = src->flags;
1070 safe_VkEventCreateInfo::safe_VkEventCreateInfo(const safe_VkEventCreateInfo& src)
1072 sType = src.sType;
1073 pNext = src.pNext;
1074 flags = src.flags;
1088 void safe_VkEventCreateInfo::initialize(const safe_VkEventCreateInfo* src)
1090 sType = src->sType;
1091 pNext = src->pNext;
1092 flags = src->flags;
1108 safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& src)
1110 sType = src.sType;
1111 pNext = src.pNext;
1112 flags = src.flags;
1113 queryType = src.queryType;
1114 queryCount = src.queryCount;
1115 pipelineStatistics = src.pipelineStatistics;
1132 void safe_VkQueryPoolCreateInfo::initialize(const safe_VkQueryPoolCreateInfo* src)
1134 sType = src->sType;
1135 pNext = src->pNext;
1136 flags = src->flags;
1137 queryType = src->queryType;
1138 queryCount = src->queryCount;
1139 pipelineStatistics = src->pipelineStatistics;
1162 safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& src)
1164 sType = src.sType;
1165 pNext = src.pNext;
1166 flags = src.flags;
1167 size = src.size;
1168 usage = src.usage;
1169 sharingMode = src.sharingMode;
1170 queueFamilyIndexCount = src.queueFamilyIndexCount;
1172 if (src.pQueueFamilyIndices) {
1173 pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
1174 memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
1200 void safe_VkBufferCreateInfo::initialize(const safe_VkBufferCreateInfo* src)
1202 sType = src->sType;
1203 pNext = src->pNext;
1204 flags = src->flags;
1205 size = src->size;
1206 usage = src->usage;
1207 sharingMode = src->sharingMode;
1208 queueFamilyIndexCount = src->queueFamilyIndexCount;
1210 if (src->pQueueFamilyIndices) {
1211 pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
1212 memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
1230 safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& src)
1232 sType = src.sType;
1233 pNext = src.pNext;
1234 flags = src.flags;
1235 buffer = src.buffer;
1236 format = src.format;
1237 offset = src.offset;
1238 range = src.range;
1256 void safe_VkBufferViewCreateInfo::initialize(const safe_VkBufferViewCreateInfo* src)
1258 sType = src->sType;
1259 pNext = src->pNext;
1260 flags = src->flags;
1261 buffer = src->buffer;
1262 format = src->format;
1263 offset = src->offset;
1264 range = src->range;
1294 safe_VkImageCreateInfo::safe_VkImageCreateInfo(const safe_VkImageCreateInfo& src)
1296 sType = src.sType;
1297 pNext = src.pNext;
1298 flags = src.flags;
1299 imageType = src.imageType;
1300 format = src.format;
1301 extent = src.extent;
1302 mipLevels = src.mipLevels;
1303 arrayLayers = src.arrayLayers;
1304 samples = src.samples;
1305 tiling = src.tiling;
1306 usage = src.usage;
1307 sharingMode = src.sharingMode;
1308 queueFamilyIndexCount = src.queueFamilyIndexCount;
1310 initialLayout = src.initialLayout;
1311 if (src.pQueueFamilyIndices) {
1312 pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
1313 memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
1346 void safe_VkImageCreateInfo::initialize(const safe_VkImageCreateInfo* src)
1348 sType = src->sType;
1349 pNext = src->pNext;
1350 flags = src->flags;
1351 imageType = src->imageType;
1352 format = src->format;
1353 extent = src->extent;
1354 mipLevels = src->mipLevels;
1355 arrayLayers = src->arrayLayers;
1356 samples = src->samples;
1357 tiling = src->tiling;
1358 usage = src->usage;
1359 sharingMode = src->sharingMode;
1360 queueFamilyIndexCount = src->queueFamilyIndexCount;
1362 initialLayout = src->initialLayout;
1363 if (src->pQueueFamilyIndices) {
1364 pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
1365 memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
1384 safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& src)
1386 sType = src.sType;
1387 pNext = src.pNext;
1388 flags = src.flags;
1389 image = src.image;
1390 viewType = src.viewType;
1391 format = src.format;
1392 components = src.components;
1393 subresourceRange = src.subresourceRange;
1412 void safe_VkImageViewCreateInfo::initialize(const safe_VkImageViewCreateInfo* src)
1414 sType = src->sType;
1415 pNext = src->pNext;
1416 flags = src->flags;
1417 image = src->image;
1418 viewType = src->viewType;
1419 format = src->format;
1420 components = src->components;
1421 subresourceRange = src->subresourceRange;
1440 safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& src)
1442 sType = src.sType;
1443 pNext = src.pNext;
1444 flags = src.flags;
1445 codeSize = src.codeSize;
1447 if (src.pCode) {
1448 pCode = new uint32_t(*src.pCode);
1470 void safe_VkShaderModuleCreateInfo::initialize(const safe_VkShaderModuleCreateInfo* src)
1472 sType = src->sType;
1473 pNext = src->pNext;
1474 flags = src->flags;
1475 codeSize = src->codeSize;
1477 if (src->pCode) {
1478 pCode = new uint32_t(*src->pCode);
1494 safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& src)
1496 sType = src.sType;
1497 pNext = src.pNext;
1498 flags = src.flags;
1499 initialDataSize = src.initialDataSize;
1500 pInitialData = src.pInitialData;
1516 void safe_VkPipelineCacheCreateInfo::initialize(const safe_VkPipelineCacheCreateInfo* src)
1518 sType = src->sType;
1519 pNext = src->pNext;
1520 flags = src->flags;
1521 initialDataSize = src->initialDataSize;
1522 pInitialData = src->pInitialData;
1541 safe_VkSpecializationInfo::safe_VkSpecializationInfo(const safe_VkSpecializationInfo& src)
1543 mapEntryCount = src.mapEntryCount;
1545 dataSize = src.dataSize;
1546 pData = src.pData;
1547 if (src.pMapEntries) {
1548 pMapEntries = new VkSpecializationMapEntry[src.mapEntryCount];
1549 memcpy ((void *)pMapEntries, (void *)src.pMapEntries, sizeof(VkSpecializationMapEntry)*src.mapEntryCount);
1571 void safe_VkSpecializationInfo::initialize(const safe_VkSpecializationInfo* src)
1573 mapEntryCount = src->mapEntryCount;
1575 dataSize = src->dataSize;
1576 pData = src->pData;
1577 if (src->pMapEntries) {
1578 pMapEntries = new VkSpecializationMapEntry[src->mapEntryCount];
1579 memcpy ((void *)pMapEntries, (void *)src->pMapEntries, sizeof(VkSpecializationMapEntry)*src->mapEntryCount);
1600 safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& src)
1602 sType = src.sType;
1603 pNext = src.pNext;
1604 flags = src.flags;
1605 stage = src.stage;
1606 module = src.module;
1607 pName = src.pName;
1608 if (src.pSpecializationInfo)
1609 pSpecializationInfo = new safe_VkSpecializationInfo(*src.pSpecializationInfo);
1634 void safe_VkPipelineShaderStageCreateInfo::initialize(const safe_VkPipelineShaderStageCreateInfo* src)
1636 sType = src->sType;
1637 pNext = src->pNext;
1638 flags = src->flags;
1639 stage = src->stage;
1640 module = src->module;
1641 pName = src->pName;
1642 if (src->pSpecializationInfo)
1643 pSpecializationInfo = new safe_VkSpecializationInfo(*src->pSpecializationInfo);
1672 safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& src)
1674 sType = src.sType;
1675 pNext = src.pNext;
1676 flags = src.flags;
1677 vertexBindingDescriptionCount = src.vertexBindingDescriptionCount;
1679 vertexAttributeDescriptionCount = src.vertexAttributeDescriptionCount;
1681 if (src.pVertexBindingDescriptions) {
1682 pVertexBindingDescriptions = new VkVertexInputBindingDescription[src.vertexBindingDescriptionCount];
1683 memcpy ((void *)pVertexBindingDescriptions, (void *)src.pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*src.vertexBindingDescriptionCount);
1685 if (src.pVertexAttributeDescriptions) {
1686 pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[src.vertexAttributeDescriptionCount];
1687 memcpy ((void *)pVertexAttributeDescriptions, (void *)src.pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*src.vertexAttributeDescriptionCount);
1718 void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipelineVertexInputStateCreateInfo* src)
1720 sType = src->sType;
1721 pNext = src->pNext;
1722 flags = src->flags;
1723 vertexBindingDescriptionCount = src->vertexBindingDescriptionCount;
1725 vertexAttributeDescriptionCount = src->vertexAttributeDescriptionCount;
1727 if (src->pVertexBindingDescriptions) {
1728 pVertexBindingDescriptions = new VkVertexInputBindingDescription[src->vertexBindingDescriptionCount];
1729 memcpy ((void *)pVertexBindingDescriptions, (void *)src->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*src->vertexBindingDescriptionCount);
1731 if (src->pVertexAttributeDescriptions) {
1732 pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[src->vertexAttributeDescriptionCount];
1733 memcpy ((void *)pVertexAttributeDescriptions, (void *)src->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*src->vertexAttributeDescriptionCount);
1749 safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& src)
1751 sType = src.sType;
1752 pNext = src.pNext;
1753 flags = src.flags;
1754 topology = src.topology;
1755 primitiveRestartEnable = src.primitiveRestartEnable;
1771 void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* src)
1773 sType = src->sType;
1774 pNext = src->pNext;
1775 flags = src->flags;
1776 topology = src->topology;
1777 primitiveRestartEnable = src->primitiveRestartEnable;
1791 safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& src)
1793 sType = src.sType;
1794 pNext = src.pNext;
1795 flags = src.flags;
1796 patchControlPoints = src.patchControlPoints;
1811 void safe_VkPipelineTessellationStateCreateInfo::initialize(const safe_VkPipelineTessellationStateCreateInfo* src)
1813 sType = src->sType;
1814 pNext = src->pNext;
1815 flags = src->flags;
1816 patchControlPoints = src->patchControlPoints;
1843 safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& src)
1845 sType = src.sType;
1846 pNext = src.pNext;
1847 flags = src.flags;
1848 viewportCount = src.viewportCount;
1850 scissorCount = src.scissorCount;
1852 if (src.pViewports) {
1853 pViewports = new VkViewport[src.viewportCount];
1854 memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);
1856 if (src.pScissors) {
1857 pScissors = new VkRect2D[src.scissorCount];
1858 memcpy ((void *)pScissors, (void *)src.pScissors, sizeof(VkRect2D)*src.scissorCount);
1889 void safe_VkPipelineViewportStateCreateInfo::initialize(const safe_VkPipelineViewportStateCreateInfo* src)
1891 sType = src->sType;
1892 pNext = src->pNext;
1893 flags = src->flags;
1894 viewportCount = src->viewportCount;
1896 scissorCount = src->scissorCount;
1898 if (src->pViewports) {
1899 pViewports = new VkViewport[src->viewportCount];
1900 memcpy ((void *)pViewports, (void *)src->pViewports, sizeof(VkViewport)*src->viewportCount);
1902 if (src->pScissors) {
1903 pScissors = new VkRect2D[src->scissorCount];
1904 memcpy ((void *)pScissors, (void *)src->pScissors, sizeof(VkRect2D)*src->scissorCount);
1928 safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& src)
1930 sType = src.sType;
1931 pNext = src.pNext;
1932 flags = src.flags;
1933 depthClampEnable = src.depthClampEnable;
1934 rasterizerDiscardEnable = src.rasterizerDiscardEnable;
1935 polygonMode = src.polygonMode;
1936 cullMode = src.cullMode;
1937 frontFace = src.frontFace;
1938 depthBiasEnable = src.depthBiasEnable;
1939 depthBiasConstantFactor = src.depthBiasConstantFactor;
1940 depthBiasClamp = src.depthBiasClamp;
1941 depthBiasSlopeFactor = src.depthBiasSlopeFactor;
1942 lineWidth = src.lineWidth;
1966 void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipelineRasterizationStateCreateInfo* src)
1968 sType = src->sType;
1969 pNext = src->pNext;
1970 flags = src->flags;
1971 depthClampEnable = src->depthClampEnable;
1972 rasterizerDiscardEnable = src->rasterizerDiscardEnable;
1973 polygonMode = src->polygonMode;
1974 cullMode = src->cullMode;
1975 frontFace = src->frontFace;
1976 depthBiasEnable = src->depthBiasEnable;
1977 depthBiasConstantFactor = src->depthBiasConstantFactor;
1978 depthBiasClamp = src->depthBiasClamp;
1979 depthBiasSlopeFactor = src->depthBiasSlopeFactor;
1980 lineWidth = src->lineWidth;
2003 safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& src)
2005 sType = src.sType;
2006 pNext = src.pNext;
2007 flags = src.flags;
2008 rasterizationSamples = src.rasterizationSamples;
2009 sampleShadingEnable = src.sampleShadingEnable;
2010 minSampleShading = src.minSampleShading;
2012 alphaToCoverageEnable = src.alphaToCoverageEnable;
2013 alphaToOneEnable = src.alphaToOneEnable;
2014 if (src.pSampleMask) {
2015 pSampleMask = new VkSampleMask(*src.pSampleMask);
2041 void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipelineMultisampleStateCreateInfo* src)
2043 sType = src->sType;
2044 pNext = src->pNext;
2045 flags = src->flags;
2046 rasterizationSamples = src->rasterizationSamples;
2047 sampleShadingEnable = src->sampleShadingEnable;
2048 minSampleShading = src->minSampleShading;
2050 alphaToCoverageEnable = src->alphaToCoverageEnable;
2051 alphaToOneEnable = src->alphaToOneEnable;
2052 if (src->pSampleMask) {
2053 pSampleMask = new VkSampleMask(*src->pSampleMask);
2076 safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& src)
2078 sType = src.sType;
2079 pNext = src.pNext;
2080 flags = src.flags;
2081 depthTestEnable = src.depthTestEnable;
2082 depthWriteEnable = src.depthWriteEnable;
2083 depthCompareOp = src.depthCompareOp;
2084 depthBoundsTestEnable = src.depthBoundsTestEnable;
2085 stencilTestEnable = src.stencilTestEnable;
2086 front = src.front;
2087 back = src.back;
2088 minDepthBounds = src.minDepthBounds;
2089 maxDepthBounds = src.maxDepthBounds;
2112 void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelineDepthStencilStateCreateInfo* src)
2114 sType = src->sType;
2115 pNext = src->pNext;
2116 flags = src->flags;
2117 depthTestEnable = src->depthTestEnable;
2118 depthWriteEnable = src->depthWriteEnable;
2119 depthCompareOp = src->depthCompareOp;
2120 depthBoundsTestEnable = src->depthBoundsTestEnable;
2121 stencilTestEnable = src->stencilTestEnable;
2122 front = src->front;
2123 back = src->back;
2124 minDepthBounds = src->minDepthBounds;
2125 maxDepthBounds = src->maxDepthBounds;
2150 safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& src)
2152 sType = src.sType;
2153 pNext = src.pNext;
2154 flags = src.flags;
2155 logicOpEnable = src.logicOpEnable;
2156 logicOp = src.logicOp;
2157 attachmentCount = src.attachmentCount;
2159 if (src.pAttachments) {
2160 pAttachments = new VkPipelineColorBlendAttachmentState[src.attachmentCount];
2161 memcpy ((void *)pAttachments, (void *)src.pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*src.attachmentCount);
2164 blendConstants[i] = src.blendConstants[i];
2192 void safe_VkPipelineColorBlendStateCreateInfo::initialize(const safe_VkPipelineColorBlendStateCreateInfo* src)
2194 sType = src->sType;
2195 pNext = src->pNext;
2196 flags = src->flags;
2197 logicOpEnable = src->logicOpEnable;
2198 logicOp = src->logicOp;
2199 attachmentCount = src->attachmentCount;
2201 if (src->pAttachments) {
2202 pAttachments = new VkPipelineColorBlendAttachmentState[src->attachmentCount];
2203 memcpy ((void *)pAttachments, (void *)src->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*src->attachmentCount);
2206 blendConstants[i] = src->blendConstants[i];
2227 safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& src)
2229 sType = src.sType;
2230 pNext = src.pNext;
2231 flags = src.flags;
2232 dynamicStateCount = src.dynamicStateCount;
2234 if (src.pDynamicStates) {
2235 pDynamicStates = new VkDynamicState[src.dynamicStateCount];
2236 memcpy ((void *)pDynamicStates, (void *)src.pDynamicStates, sizeof(VkDynamicState)*src.dynamicStateCount);
2259 void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDynamicStateCreateInfo* src)
2261 sType = src->sType;
2262 pNext = src->pNext;
2263 flags = src->flags;
2264 dynamicStateCount = src->dynamicStateCount;
2266 if (src->pDynamicStates) {
2267 pDynamicStates = new VkDynamicState[src->dynamicStateCount];
2268 memcpy ((void *)pDynamicStates, (void *)src->pDynamicStates, sizeof(VkDynamicState)*src->dynamicStateCount);
2332 safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& src)
2334 sType = src.sType;
2335 pNext = src.pNext;
2336 flags = src.flags;
2337 stageCount = src.stageCount;
2339 layout = src.layout;
2340 renderPass = src.renderPass;
2341 subpass = src.subpass;
2342 basePipelineHandle = src.basePipelineHandle;
2343 basePipelineIndex = src.basePipelineIndex;
2344 if (stageCount && src.pStages) {
2347 pStages[i].initialize(&src.pStages[i]);
2350 if (src.pVertexInputState)
2351 pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*src.pVertexInputState);
2354 if (src.pInputAssemblyState)
2355 pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*src.pInputAssemblyState);
2358 if (src.pTessellationState)
2359 pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*src.pTessellationState);
2362 if (src.pViewportState)
2363 pViewportState = new safe_VkPipelineViewportStateCreateInfo(*src.pViewportState);
2366 if (src.pRasterizationState)
2367 pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*src.pRasterizationState);
2370 if (src.pMultisampleState)
2371 pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*src.pMultisampleState);
2374 if (src.pDepthStencilState)
2375 pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*src.pDepthStencilState);
2378 if (src.pColorBlendState)
2379 pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*src.pColorBlendState);
2382 if (src.pDynamicState)
2383 pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*src.pDynamicState);
2468 void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipelineCreateInfo* src)
2470 sType = src->sType;
2471 pNext = src->pNext;
2472 flags = src->flags;
2473 stageCount = src->stageCount;
2475 layout = src->layout;
2476 renderPass = src->renderPass;
2477 subpass = src->subpass;
2478 basePipelineHandle = src->basePipelineHandle;
2479 basePipelineIndex = src->basePipelineIndex;
2480 if (stageCount && src->pStages) {
2483 pStages[i].initialize(&src->pStages[i]);
2486 if (src->pVertexInputState)
2487 pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*src->pVertexInputState);
2490 if (src->pInputAssemblyState)
2491 pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*src->pInputAssemblyState);
2494 if (src->pTessellationState)
2495 pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*src->pTessellationState);
2498 if (src->pViewportState)
2499 pViewportState = new safe_VkPipelineViewportStateCreateInfo(*src->pViewportState);
2502 if (src->pRasterizationState)
2503 pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*src->pRasterizationState);
2506 if (src->pMultisampleState)
2507 pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*src->pMultisampleState);
2510 if (src->pDepthStencilState)
2511 pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*src->pDepthStencilState);
2514 if (src->pColorBlendState)
2515 pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*src->pColorBlendState);
2518 if (src->pDynamicState)
2519 pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*src->pDynamicState);
2538 safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& src)
2540 sType = src.sType;
2541 pNext = src.pNext;
2542 flags = src.flags;
2543 stage.initialize(&src.stage);
2544 layout = src.layout;
2545 basePipelineHandle = src.basePipelineHandle;
2546 basePipelineIndex = src.basePipelineIndex;
2564 void safe_VkComputePipelineCreateInfo::initialize(const safe_VkComputePipelineCreateInfo* src)
2566 sType = src->sType;
2567 pNext = src->pNext;
2568 flags = src->flags;
2569 stage.initialize(&src->stage);
2570 layout = src->layout;
2571 basePipelineHandle = src->basePipelineHandle;
2572 basePipelineIndex = src->basePipelineIndex;
2601 safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& src)
2603 sType = src.sType;
2604 pNext = src.pNext;
2605 flags = src.flags;
2606 setLayoutCount = src.setLayoutCount;
2608 pushConstantRangeCount = src.pushConstantRangeCount;
2610 if (setLayoutCount && src.pSetLayouts) {
2613 pSetLayouts[i] = src.pSetLayouts[i];
2616 if (src.pPushConstantRanges) {
2617 pPushConstantRanges = new VkPushConstantRange[src.pushConstantRangeCount];
2618 memcpy ((void *)pPushConstantRanges, (void *)src.pPushConstantRanges, sizeof(VkPushConstantRange)*src.pushConstantRangeCount);
2651 void safe_VkPipelineLayoutCreateInfo::initialize(const safe_VkPipelineLayoutCreateInfo* src)
2653 sType = src->sType;
2654 pNext = src->pNext;
2655 flags = src->flags;
2656 setLayoutCount = src->setLayoutCount;
2658 pushConstantRangeCount = src->pushConstantRangeCount;
2660 if (setLayoutCount && src->pSetLayouts) {
2663 pSetLayouts[i] = src->pSetLayouts[i];
2666 if (src->pPushConstantRanges) {
2667 pPushConstantRanges = new VkPushConstantRange[src->pushConstantRangeCount];
2668 memcpy ((void *)pPushConstantRanges, (void *)src->pPushConstantRanges, sizeof(VkPushConstantRange)*src->pushConstantRangeCount);
2697 safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& src)
2699 sType = src.sType;
2700 pNext = src.pNext;
2701 flags = src.flags;
2702 magFilter = src.magFilter;
2703 minFilter = src.minFilter;
2704 mipmapMode = src.mipmapMode;
2705 addressModeU = src.addressModeU;
2706 addressModeV = src.addressModeV;
2707 addressModeW = src.addressModeW;
2708 mipLodBias = src.mipLodBias;
2709 anisotropyEnable = src.anisotropyEnable;
2710 maxAnisotropy = src.maxAnisotropy;
2711 compareEnable = src.compareEnable;
2712 compareOp = src.compareOp;
2713 minLod = src.minLod;
2714 maxLod = src.maxLod;
2715 borderColor = src.borderColor;
2716 unnormalizedCoordinates = src.unnormalizedCoordinates;
2745 void safe_VkSamplerCreateInfo::initialize(const safe_VkSamplerCreateInfo* src)
2747 sType = src->sType;
2748 pNext = src->pNext;
2749 flags = src->flags;
2750 magFilter = src->magFilter;
2751 minFilter = src->minFilter;
2752 mipmapMode = src->mipmapMode;
2753 addressModeU = src->addressModeU;
2754 addressModeV = src->addressModeV;
2755 addressModeW = src->addressModeW;
2756 mipLodBias = src->mipLodBias;
2757 anisotropyEnable = src->anisotropyEnable;
2758 maxAnisotropy = src->maxAnisotropy;
2759 compareEnable = src->compareEnable;
2760 compareOp = src->compareOp;
2761 minLod = src->minLod;
2762 maxLod = src->maxLod;
2763 borderColor = src->borderColor;
2764 unnormalizedCoordinates = src->unnormalizedCoordinates;
2786 safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& src)
2788 binding = src.binding;
2789 descriptorType = src.descriptorType;
2790 descriptorCount = src.descriptorCount;
2791 stageFlags = src.stageFlags;
2793 if (descriptorCount && src.pImmutableSamplers) {
2796 pImmutableSamplers[i] = src.pImmutableSamplers[i];
2822 void safe_VkDescriptorSetLayoutBinding::initialize(const safe_VkDescriptorSetLayoutBinding* src)
2824 binding = src->binding;
2825 descriptorType = src->descriptorType;
2826 descriptorCount = src->descriptorCount;
2827 stageFlags = src->stageFlags;
2829 if (descriptorCount && src->pImmutableSamplers) {
2832 pImmutableSamplers[i] = src->pImmutableSamplers[i];
2856 safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& src)
2858 sType = src.sType;
2859 pNext = src.pNext;
2860 flags = src.flags;
2861 bindingCount = src.bindingCount;
2863 if (bindingCount && src.pBindings) {
2866 pBindings[i].initialize(&src.pBindings[i]);
2892 void safe_VkDescriptorSetLayoutCreateInfo::initialize(const safe_VkDescriptorSetLayoutCreateInfo* src)
2894 sType = src->sType;
2895 pNext = src->pNext;
2896 flags = src->flags;
2897 bindingCount = src->bindingCount;
2899 if (bindingCount && src->pBindings) {
2902 pBindings[i].initialize(&src->pBindings[i]);
2925 safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& src)
2927 sType = src.sType;
2928 pNext = src.pNext;
2929 flags = src.flags;
2930 maxSets = src.maxSets;
2931 poolSizeCount = src.poolSizeCount;
2933 if (src.pPoolSizes) {
2934 pPoolSizes = new VkDescriptorPoolSize[src.poolSizeCount];
2935 memcpy ((void *)pPoolSizes, (void *)src.pPoolSizes, sizeof(VkDescriptorPoolSize)*src.poolSizeCount);
2959 void safe_VkDescriptorPoolCreateInfo::initialize(const safe_VkDescriptorPoolCreateInfo* src)
2961 sType = src->sType;
2962 pNext = src->pNext;
2963 flags = src->flags;
2964 maxSets = src->maxSets;
2965 poolSizeCount = src->poolSizeCount;
2967 if (src->pPoolSizes) {
2968 pPoolSizes = new VkDescriptorPoolSize[src->poolSizeCount];
2969 memcpy ((void *)pPoolSizes, (void *)src->pPoolSizes, sizeof(VkDescriptorPoolSize)*src->poolSizeCount);
2992 safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& src)
2994 sType = src.sType;
2995 pNext = src.pNext;
2996 descriptorPool = src.descriptorPool;
2997 descriptorSetCount = src.descriptorSetCount;
2999 if (descriptorSetCount && src.pSetLayouts) {
3002 pSetLayouts[i] = src.pSetLayouts[i];
3028 void safe_VkDescriptorSetAllocateInfo::initialize(const safe_VkDescriptorSetAllocateInfo* src)
3030 sType = src->sType;
3031 pNext = src->pNext;
3032 descriptorPool = src->descriptorPool;
3033 descriptorSetCount = src->descriptorSetCount;
3035 if (descriptorSetCount && src->pSetLayouts) {
3038 pSetLayouts[i] = src->pSetLayouts[i];
3099 safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& src)
3101 sType = src.sType;
3102 pNext = src.pNext;
3103 dstSet = src.dstSet;
3104 dstBinding = src.dstBinding;
3105 dstArrayElement = src.dstArrayElement;
3106 descriptorCount = src.descriptorCount;
3107 descriptorType = src.descriptorType;
3117 if (descriptorCount && src.pImageInfo) {
3120 pImageInfo[i] = src.pImageInfo[i];
3128 if (descriptorCount && src.pBufferInfo) {
3131 pBufferInfo[i] = src.pBufferInfo[i];
3137 if (descriptorCount && src.pTexelBufferView) {
3140 pTexelBufferView[i] = src.pTexelBufferView[i];
3209 void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* src)
3211 sType = src->sType;
3212 pNext = src->pNext;
3213 dstSet = src->dstSet;
3214 dstBinding = src->dstBinding;
3215 dstArrayElement = src->dstArrayElement;
3216 descriptorCount = src->descriptorCount;
3217 descriptorType = src->descriptorType;
3227 if (descriptorCount && src->pImageInfo) {
3230 pImageInfo[i] = src->pImageInfo[i];
3238 if (descriptorCount && src->pBufferInfo) {
3241 pBufferInfo[i] = src->pBufferInfo[i];
3247 if (descriptorCount && src->pTexelBufferView) {
3250 pTexelBufferView[i] = src->pTexelBufferView[i];
3275 safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& src)
3277 sType = src.sType;
3278 pNext = src.pNext;
3279 srcSet = src.srcSet;
3280 srcBinding = src.srcBinding;
3281 srcArrayElement = src.srcArrayElement;
3282 dstSet = src.dstSet;
3283 dstBinding = src.dstBinding;
3284 dstArrayElement = src.dstArrayElement;
3285 descriptorCount = src.descriptorCount;
3305 void safe_VkCopyDescriptorSet::initialize(const safe_VkCopyDescriptorSet* src)
3307 sType = src->sType;
3308 pNext = src->pNext;
3309 srcSet = src->srcSet;
3310 srcBinding = src->srcBinding;
3311 srcArrayElement = src->srcArrayElement;
3312 dstSet = src->dstSet;
3313 dstBinding = src->dstBinding;
3314 dstArrayElement = src->dstArrayElement;
3315 descriptorCount = src->descriptorCount;
3341 safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& src)
3343 sType = src.sType;
3344 pNext = src.pNext;
3345 flags = src.flags;
3346 renderPass = src.renderPass;
3347 attachmentCount = src.attachmentCount;
3349 width = src.width;
3350 height = src.height;
3351 layers = src.layers;
3352 if (attachmentCount && src.pAttachments) {
3355 pAttachments[i] = src.pAttachments[i];
3385 void safe_VkFramebufferCreateInfo::initialize(const safe_VkFramebufferCreateInfo* src)
3387 sType = src->sType;
3388 pNext = src->pNext;
3389 flags = src->flags;
3390 renderPass = src->renderPass;
3391 attachmentCount = src->attachmentCount;
3393 width = src->width;
3394 height = src->height;
3395 layers = src->layers;
3396 if (attachmentCount && src->pAttachments) {
3399 pAttachments[i] = src->pAttachments[i];
3445 safe_VkSubpassDescription::safe_VkSubpassDescription(const safe_VkSubpassDescription& src)
3447 flags = src.flags;
3448 pipelineBindPoint = src.pipelineBindPoint;
3449 inputAttachmentCount = src.inputAttachmentCount;
3451 colorAttachmentCount = src.colorAttachmentCount;
3455 preserveAttachmentCount = src.preserveAttachmentCount;
3457 if (src.pInputAttachments) {
3458 pInputAttachments = new VkAttachmentReference[src.inputAttachmentCount];
3459 memcpy ((void *)pInputAttachments, (void *)src.pInputAttachments, sizeof(VkAttachmentReference)*src.inputAttachmentCount);
3461 if (src.pColorAttachments) {
3462 pColorAttachments = new VkAttachmentReference[src.colorAttachmentCount];
3463 memcpy ((void *)pColorAttachments, (void *)src.pColorAttachments, sizeof(VkAttachmentReference)*src.colorAttachmentCount);
3465 if (src.pResolveAttachments) {
3466 pResolveAttachments = new VkAttachmentReference[src.colorAttachmentCount];
3467 memcpy ((void *)pResolveAttachments, (void *)src.pResolveAttachments, sizeof(VkAttachmentReference)*src.colorAttachmentCount);
3469 if (src.pDepthStencilAttachment) {
3470 pDepthStencilAttachment = new VkAttachmentReference(*src.pDepthStencilAttachment);
3472 if (src.pPreserveAttachments) {
3473 pPreserveAttachments = new uint32_t[src.preserveAttachmentCount];
3474 memcpy ((void *)pPreserveAttachments, (void *)src.pPreserveAttachments, sizeof(uint32_t)*src.preserveAttachmentCount);
3525 void safe_VkSubpassDescription::initialize(const safe_VkSubpassDescription* src)
3527 flags = src->flags;
3528 pipelineBindPoint = src->pipelineBindPoint;
3529 inputAttachmentCount = src->inputAttachmentCount;
3531 colorAttachmentCount = src->colorAttachmentCount;
3535 preserveAttachmentCount = src->preserveAttachmentCount;
3537 if (src->pInputAttachments) {
3538 pInputAttachments = new VkAttachmentReference[src->inputAttachmentCount];
3539 memcpy ((void *)pInputAttachments, (void *)src->pInputAttachments, sizeof(VkAttachmentReference)*src->inputAttachmentCount);
3541 if (src->pColorAttachments) {
3542 pColorAttachments = new VkAttachmentReference[src->colorAttachmentCount];
3543 memcpy ((void *)pColorAttachments, (void *)src->pColorAttachments, sizeof(VkAttachmentReference)*src->colorAttachmentCount);
3545 if (src->pResolveAttachments) {
3546 pResolveAttachments = new VkAttachmentReference[src->colorAttachmentCount];
3547 memcpy ((void *)pResolveAttachments, (void *)src->pResolveAttachments, sizeof(VkAttachmentReference)*src->colorAttachmentCount);
3549 if (src->pDepthStencilAttachment) {
3550 pDepthStencilAttachment = new VkAttachmentReference(*src->pDepthStencilAttachment);
3552 if (src->pPreserveAttachments) {
3553 pPreserveAttachments = new uint32_t[src->preserveAttachmentCount];
3554 memcpy ((void *)pPreserveAttachments, (void *)src->pPreserveAttachments, sizeof(uint32_t)*src->preserveAttachmentCount);
3591 safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& src)
3593 sType = src.sType;
3594 pNext = src.pNext;
3595 flags = src.flags;
3596 attachmentCount = src.attachmentCount;
3598 subpassCount = src.subpassCount;
3600 dependencyCount = src.dependencyCount;
3602 if (src.pAttachments) {
3603 pAttachments = new VkAttachmentDescription[src.attachmentCount];
3604 memcpy ((void *)pAttachments, (void *)src.pAttachments, sizeof(VkAttachmentDescription)*src.attachmentCount);
3606 if (subpassCount && src.pSubpasses) {
3609 pSubpasses[i].initialize(&src.pSubpasses[i]);
3612 if (src.pDependencies) {
3613 pDependencies = new VkSubpassDependency[src.dependencyCount];
3614 memcpy ((void *)pDependencies, (void *)src.pDependencies, sizeof(VkSubpassDependency)*src.dependencyCount);
3655 void safe_VkRenderPassCreateInfo::initialize(const safe_VkRenderPassCreateInfo* src)
3657 sType = src->sType;
3658 pNext = src->pNext;
3659 flags = src->flags;
3660 attachmentCount = src->attachmentCount;
3662 subpassCount = src->subpassCount;
3664 dependencyCount = src->dependencyCount;
3666 if (src->pAttachments) {
3667 pAttachments = new VkAttachmentDescription[src->attachmentCount];
3668 memcpy ((void *)pAttachments, (void *)src->pAttachments, sizeof(VkAttachmentDescription)*src->attachmentCount);
3670 if (subpassCount && src->pSubpasses) {
3673 pSubpasses[i].initialize(&src->pSubpasses[i]);
3676 if (src->pDependencies) {
3677 pDependencies = new VkSubpassDependency[src->dependencyCount];
3678 memcpy ((void *)pDependencies, (void *)src->pDependencies, sizeof(VkSubpassDependency)*src->dependencyCount);
3693 safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& src)
3695 sType = src.sType;
3696 pNext = src.pNext;
3697 flags = src.flags;
3698 queueFamilyIndex = src.queueFamilyIndex;
3713 void safe_VkCommandPoolCreateInfo::initialize(const safe_VkCommandPoolCreateInfo* src)
3715 sType = src->sType;
3716 pNext = src->pNext;
3717 flags = src->flags;
3718 queueFamilyIndex = src->queueFamilyIndex;
3733 safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& src)
3735 sType = src.sType;
3736 pNext = src.pNext;
3737 commandPool = src.commandPool;
3738 level = src.level;
3739 commandBufferCount = src.commandBufferCount;
3755 void safe_VkCommandBufferAllocateInfo::initialize(const safe_VkCommandBufferAllocateInfo* src)
3757 sType = src->sType;
3758 pNext = src->pNext;
3759 commandPool = src->commandPool;
3760 level = src->level;
3761 commandBufferCount = src->commandBufferCount;
3779 safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& src)
3781 sType = src.sType;
3782 pNext = src.pNext;
3783 renderPass = src.renderPass;
3784 subpass = src.subpass;
3785 framebuffer = src.framebuffer;
3786 occlusionQueryEnable = src.occlusionQueryEnable;
3787 queryFlags = src.queryFlags;
3788 pipelineStatistics = src.pipelineStatistics;
3807 void safe_VkCommandBufferInheritanceInfo::initialize(const safe_VkCommandBufferInheritanceInfo* src)
3809 sType = src->sType;
3810 pNext = src->pNext;
3811 renderPass = src->renderPass;
3812 subpass = src->subpass;
3813 framebuffer = src->framebuffer;
3814 occlusionQueryEnable = src->occlusionQueryEnable;
3815 queryFlags = src->queryFlags;
3816 pipelineStatistics = src->pipelineStatistics;
3833 safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& src)
3835 sType = src.sType;
3836 pNext = src.pNext;
3837 flags = src.flags;
3838 if (src.pInheritanceInfo)
3839 pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*src.pInheritanceInfo);
3861 void safe_VkCommandBufferBeginInfo::initialize(const safe_VkCommandBufferBeginInfo* src)
3863 sType = src->sType;
3864 pNext = src->pNext;
3865 flags = src->flags;
3866 if (src->pInheritanceInfo)
3867 pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*src->pInheritanceInfo);
3883 safe_VkMemoryBarrier::safe_VkMemoryBarrier(const safe_VkMemoryBarrier& src)
3885 sType = src.sType;
3886 pNext = src.pNext;
3887 srcAccessMask = src.srcAccessMask;
3888 dstAccessMask = src.dstAccessMask;
3903 void safe_VkMemoryBarrier::initialize(const safe_VkMemoryBarrier* src)
3905 sType = src->sType;
3906 pNext = src->pNext;
3907 srcAccessMask = src->srcAccessMask;
3908 dstAccessMask = src->dstAccessMask;
3927 safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& src)
3929 sType = src.sType;
3930 pNext = src.pNext;
3931 srcAccessMask = src.srcAccessMask;
3932 dstAccessMask = src.dstAccessMask;
3933 srcQueueFamilyIndex = src.srcQueueFamilyIndex;
3934 dstQueueFamilyIndex = src.dstQueueFamilyIndex;
3935 buffer = src.buffer;
3936 offset = src.offset;
3937 size = src.size;
3957 void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* src)
3959 sType = src->sType;
3960 pNext = src->pNext;
3961 srcAccessMask = src->srcAccessMask;
3962 dstAccessMask = src->dstAccessMask;
3963 srcQueueFamilyIndex = src->srcQueueFamilyIndex;
3964 dstQueueFamilyIndex = src->dstQueueFamilyIndex;
3965 buffer = src->buffer;
3966 offset = src->offset;
3967 size = src->size;
3987 safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& src)
3989 sType = src.sType;
3990 pNext = src.pNext;
3991 srcAccessMask = src.srcAccessMask;
3992 dstAccessMask = src.dstAccessMask;
3993 oldLayout = src.oldLayout;
3994 newLayout = src.newLayout;
3995 srcQueueFamilyIndex = src.srcQueueFamilyIndex;
3996 dstQueueFamilyIndex = src.dstQueueFamilyIndex;
3997 image = src.image;
3998 subresourceRange = src.subresourceRange;
4019 void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* src)
4021 sType = src->sType;
4022 pNext = src->pNext;
4023 srcAccessMask = src->srcAccessMask;
4024 dstAccessMask = src->dstAccessMask;
4025 oldLayout = src->oldLayout;
4026 newLayout = src->newLayout;
4027 srcQueueFamilyIndex = src->srcQueueFamilyIndex;
4028 dstQueueFamilyIndex = src->dstQueueFamilyIndex;
4029 image = src->image;
4030 subresourceRange = src->subresourceRange;
4052 safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& src)
4054 sType = src.sType;
4055 pNext = src.pNext;
4056 renderPass = src.renderPass;
4057 framebuffer = src.framebuffer;
4058 renderArea = src.renderArea;
4059 clearValueCount = src.clearValueCount;
4061 if (src.pClearValues) {
4062 pClearValues = new VkClearValue[src.clearValueCount];
4063 memcpy ((void *)pClearValues, (void *)src.pClearValues, sizeof(VkClearValue)*src.clearValueCount);
4088 void safe_VkRenderPassBeginInfo::initialize(const safe_VkRenderPassBeginInfo* src)
4090 sType = src->sType;
4091 pNext = src->pNext;
4092 renderPass = src->renderPass;
4093 framebuffer = src->framebuffer;
4094 renderArea = src->renderArea;
4095 clearValueCount = src->clearValueCount;
4097 if (src->pClearValues) {
4098 pClearValues = new VkClearValue[src->clearValueCount];
4099 memcpy ((void *)pClearValues, (void *)src->pClearValues, sizeof(VkClearValue)*src->clearValueCount);
4128 safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& src)
4130 sType = src.sType;
4131 pNext = src.pNext;
4132 flags = src.flags;
4133 surface = src.surface;
4134 minImageCount = src.minImageCount;
4135 imageFormat = src.imageFormat;
4136 imageColorSpace = src.imageColorSpace;
4137 imageExtent = src.imageExtent;
4138 imageArrayLayers = src.imageArrayLayers;
4139 imageUsage = src.imageUsage;
4140 imageSharingMode = src.imageSharingMode;
4141 queueFamilyIndexCount = src.queueFamilyIndexCount;
4142 pQueueFamilyIndices = src.pQueueFamilyIndices;
4143 preTransform = src.preTransform;
4144 compositeAlpha = src.compositeAlpha;
4145 presentMode = src.presentMode;
4146 clipped = src.clipped;
4147 oldSwapchain = src.oldSwapchain;
4176 void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoKHR* src)
4178 sType = src->sType;
4179 pNext = src->pNext;
4180 flags = src->flags;
4181 surface = src->surface;
4182 minImageCount = src->minImageCount;
4183 imageFormat = src->imageFormat;
4184 imageColorSpace = src->imageColorSpace;
4185 imageExtent = src->imageExtent;
4186 imageArrayLayers = src->imageArrayLayers;
4187 imageUsage = src->imageUsage;
4188 imageSharingMode = src->imageSharingMode;
4189 queueFamilyIndexCount = src->queueFamilyIndexCount;
4190 pQueueFamilyIndices = src->pQueueFamilyIndices;
4191 preTransform = src->preTransform;
4192 compositeAlpha = src->compositeAlpha;
4193 presentMode = src->presentMode;
4194 clipped = src->clipped;
4195 oldSwapchain = src->oldSwapchain;
4227 safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& src)
4229 sType = src.sType;
4230 pNext = src.pNext;
4231 waitSemaphoreCount = src.waitSemaphoreCount;
4233 swapchainCount = src.swapchainCount;
4235 pImageIndices = src.pImageIndices;
4236 pResults = src.pResults;
4237 if (waitSemaphoreCount && src.pWaitSemaphores) {
4240 pWaitSemaphores[i] = src.pWaitSemaphores[i];
4243 if (swapchainCount && src.pSwapchains) {
4246 pSwapchains[i] = src.pSwapchains[i];
4283 void safe_VkPresentInfoKHR::initialize(const safe_VkPresentInfoKHR* src)
4285 sType = src->sType;
4286 pNext = src->pNext;
4287 waitSemaphoreCount = src->waitSemaphoreCount;
4289 swapchainCount = src->swapchainCount;
4291 pImageIndices = src->pImageIndices;
4292 pResults = src->pResults;
4293 if (waitSemaphoreCount && src->pWaitSemaphores) {
4296 pWaitSemaphores[i] = src->pWaitSemaphores[i];
4299 if (swapchainCount && src->pSwapchains) {
4302 pSwapchains[i] = src->pSwapchains[i];
4321 safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& src)
4323 display = src.display;
4324 displayName = src.displayName;
4325 physicalDimensions = src.physicalDimensions;
4326 physicalResolution = src.physicalResolution;
4327 supportedTransforms = src.supportedTransforms;
4328 planeReorderPossible = src.planeReorderPossible;
4329 persistentContent = src.persistentContent;
4347 void safe_VkDisplayPropertiesKHR::initialize(const safe_VkDisplayPropertiesKHR* src)
4349 display = src->display;
4350 displayName = src->displayName;
4351 physicalDimensions = src->physicalDimensions;
4352 physicalResolution = src->physicalResolution;
4353 supportedTransforms = src->supportedTransforms;
4354 planeReorderPossible = src->planeReorderPossible;
4355 persistentContent = src->persistentContent;
4367 safe_VkDisplayModePropertiesKHR::safe_VkDisplayModePropertiesKHR(const safe_VkDisplayModePropertiesKHR& src)
4369 displayMode = src.displayMode;
4370 parameters = src.parameters;
4383 void safe_VkDisplayModePropertiesKHR::initialize(const safe_VkDisplayModePropertiesKHR* src)
4385 displayMode = src->displayMode;
4386 parameters = src->parameters;
4400 safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& src)
4402 sType = src.sType;
4403 pNext = src.pNext;
4404 flags = src.flags;
4405 parameters = src.parameters;
4420 void safe_VkDisplayModeCreateInfoKHR::initialize(const safe_VkDisplayModeCreateInfoKHR* src)
4422 sType = src->sType;
4423 pNext = src->pNext;
4424 flags = src->flags;
4425 parameters = src->parameters;
4437 safe_VkDisplayPlanePropertiesKHR::safe_VkDisplayPlanePropertiesKHR(const safe_VkDisplayPlanePropertiesKHR& src)
4439 currentDisplay = src.currentDisplay;
4440 currentStackIndex = src.currentStackIndex;
4453 void safe_VkDisplayPlanePropertiesKHR::initialize(const safe_VkDisplayPlanePropertiesKHR* src)
4455 currentDisplay = src->currentDisplay;
4456 currentStackIndex = src->currentStackIndex;
4476 safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& src)
4478 sType = src.sType;
4479 pNext = src.pNext;
4480 flags = src.flags;
4481 displayMode = src.displayMode;
4482 planeIndex = src.planeIndex;
4483 planeStackIndex = src.planeStackIndex;
4484 transform = src.transform;
4485 globalAlpha = src.globalAlpha;
4486 alphaMode = src.alphaMode;
4487 imageExtent = src.imageExtent;
4508 void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const safe_VkDisplaySurfaceCreateInfoKHR* src)
4510 sType = src->sType;
4511 pNext = src->pNext;
4512 flags = src->flags;
4513 displayMode = src->displayMode;
4514 planeIndex = src->planeIndex;
4515 planeStackIndex = src->planeStackIndex;
4516 transform = src->transform;
4517 globalAlpha = src->globalAlpha;
4518 alphaMode = src->alphaMode;
4519 imageExtent = src->imageExtent;
4534 safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& src)
4536 sType = src.sType;
4537 pNext = src.pNext;
4538 srcRect = src.srcRect;
4539 dstRect = src.dstRect;
4540 persistent = src.persistent;
4556 void safe_VkDisplayPresentInfoKHR::initialize(const safe_VkDisplayPresentInfoKHR* src)
4558 sType = src->sType;
4559 pNext = src->pNext;
4560 srcRect = src->srcRect;
4561 dstRect = src->dstRect;
4562 persistent = src->persistent;
4578 safe_VkXlibSurfaceCreateInfoKHR::safe_VkXlibSurfaceCreateInfoKHR(const safe_VkXlibSurfaceCreateInfoKHR& src)
4580 sType = src.sType;
4581 pNext = src.pNext;
4582 flags = src.flags;
4583 dpy = src.dpy;
4584 window = src.window;
4600 void safe_VkXlibSurfaceCreateInfoKHR::initialize(const safe_VkXlibSurfaceCreateInfoKHR* src)
4602 sType = src->sType;
4603 pNext = src->pNext;
4604 flags = src->flags;
4605 dpy = src->dpy;
4606 window = src->window;
4623 safe_VkXcbSurfaceCreateInfoKHR::safe_VkXcbSurfaceCreateInfoKHR(const safe_VkXcbSurfaceCreateInfoKHR& src)
4625 sType = src.sType;
4626 pNext = src.pNext;
4627 flags = src.flags;
4628 connection = src.connection;
4629 window = src.window;
4645 void safe_VkXcbSurfaceCreateInfoKHR::initialize(const safe_VkXcbSurfaceCreateInfoKHR* src)
4647 sType = src->sType;
4648 pNext = src->pNext;
4649 flags = src->flags;
4650 connection = src->connection;
4651 window = src->window;
4668 safe_VkWaylandSurfaceCreateInfoKHR::safe_VkWaylandSurfaceCreateInfoKHR(const safe_VkWaylandSurfaceCreateInfoKHR& src)
4670 sType = src.sType;
4671 pNext = src.pNext;
4672 flags = src.flags;
4673 display = src.display;
4674 surface = src.surface;
4690 void safe_VkWaylandSurfaceCreateInfoKHR::initialize(const safe_VkWaylandSurfaceCreateInfoKHR* src)
4692 sType = src->sType;
4693 pNext = src->pNext;
4694 flags = src->flags;
4695 display = src->display;
4696 surface = src->surface;
4713 safe_VkMirSurfaceCreateInfoKHR::safe_VkMirSurfaceCreateInfoKHR(const safe_VkMirSurfaceCreateInfoKHR& src)
4715 sType = src.sType;
4716 pNext = src.pNext;
4717 flags = src.flags;
4718 connection = src.connection;
4719 mirSurface = src.mirSurface;
4735 void safe_VkMirSurfaceCreateInfoKHR::initialize(const safe_VkMirSurfaceCreateInfoKHR* src)
4737 sType = src->sType;
4738 pNext = src->pNext;
4739 flags = src->flags;
4740 connection = src->connection;
4741 mirSurface = src->mirSurface;
4757 safe_VkAndroidSurfaceCreateInfoKHR::safe_VkAndroidSurfaceCreateInfoKHR(const safe_VkAndroidSurfaceCreateInfoKHR& src)
4759 sType = src.sType;
4760 pNext = src.pNext;
4761 flags = src.flags;
4762 window = src.window;
4777 void safe_VkAndroidSurfaceCreateInfoKHR::initialize(const safe_VkAndroidSurfaceCreateInfoKHR* src)
4779 sType = src->sType;
4780 pNext = src->pNext;
4781 flags = src->flags;
4782 window = src->window;
4799 safe_VkWin32SurfaceCreateInfoKHR::safe_VkWin32SurfaceCreateInfoKHR(const safe_VkWin32SurfaceCreateInfoKHR& src)
4801 sType = src.sType;
4802 pNext = src.pNext;
4803 flags = src.flags;
4804 hinstance = src.hinstance;
4805 hwnd = src.hwnd;
4821 void safe_VkWin32SurfaceCreateInfoKHR::initialize(const safe_VkWin32SurfaceCreateInfoKHR* src)
4823 sType = src->sType;
4824 pNext = src->pNext;
4825 flags = src
4826 hinstance = src->hinstance;
4827 hwnd = src->hwnd;
4843 safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& src)
4845 sType = src.sType;
4846 pNext = src.pNext;
4847 flags = src.flags;
4848 pfnCallback = src.pfnCallback;
4849 pUserData = src.pUserData;
4865 void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const safe_VkDebugReportCallbackCreateInfoEXT* src)
4867 sType = src->sType;
4868 pNext = src->pNext;
4869 flags = src->flags;
4870 pfnCallback = src->pfnCallback;
4871 pUserData = src->pUserData;
4884 safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src)
4886 sType = src.sType;
4887 pNext = src.pNext;
4888 rasterizationOrder = src.rasterizationOrder;
4902 void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* src)
4904 sType = src->sType;
4905 pNext = src->pNext;
4906 rasterizationOrder = src->rasterizationOrder;
4921 safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& src)
4923 sType = src.sType;
4924 pNext = src.pNext;
4925 objectType = src.objectType;
4926 object = src.object;
4927 pObjectName = src.pObjectName;
4943 void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const safe_VkDebugMarkerObjectNameInfoEXT* src)
4945 sType = src->sType;
4946 pNext = src->pNext;
4947 objectType = src->objectType;
4948 object = src->object;
4949 pObjectName = src->pObjectName;
4966 safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& src)
4968 sType = src.sType;
4969 pNext = src.pNext;
4970 objectType = src.objectType;
4971 object = src.object;
4972 tagName = src.tagName;
4973 tagSize = src.tagSize;
4974 pTag = src.pTag;
4992 void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const safe_VkDebugMarkerObjectTagInfoEXT* src)
4994 sType = src->sType;
4995 pNext = src->pNext;
4996 objectType = src->objectType;
4997 object = src->object;
4998 tagName = src->tagName;
4999 tagSize = src->tagSize;
5000 pTag = src->pTag;
5016 safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& src)
5018 sType = src.sType;
5019 pNext = src.pNext;
5020 pMarkerName = src.pMarkerName;
5022 color[i] = src.color[i];
5040 void safe_VkDebugMarkerMarkerInfoEXT::initialize(const safe_VkDebugMarkerMarkerInfoEXT* src)
5042 sType = src->sType;
5043 pNext = src->pNext;
5044 pMarkerName = src->pMarkerName;
5046 color[i] = src->color[i];
5060 safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& src)
5062 sType = src.sType;
5063 pNext = src.pNext;
5064 dedicatedAllocation = src.dedicatedAllocation;
5078 void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* src)
5080 sType = src->sType;
5081 pNext = src->pNext;
5082 dedicatedAllocation = src->dedicatedAllocation;
5095 safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& src)
5097 sType = src.sType;
5098 pNext = src.pNext;
5099 dedicatedAllocation = src.dedicatedAllocation;
5113 void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* src)
5115 sType = src->sType;
5116 pNext = src->pNext;
5117 dedicatedAllocation = src->dedicatedAllocation;
5131 safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src)
5133 sType = src.sType;
5134 pNext = src.pNext;
5135 image = src.image;
5136 buffer = src.buffer;
5151 void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* src)
5153 sType = src->sType;
5154 pNext = src->pNext;
5155 image = src->image;
5156 buffer = src->buffer;
5169 safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& src)
5171 sType = src.sType;
5172 pNext = src.pNext;
5173 handleTypes = src.handleTypes;
5187 void safe_VkExternalMemoryImageCreateInfoNV::initialize(const safe_VkExternalMemoryImageCreateInfoNV* src)
5189 sType = src->sType;
5190 pNext = src->pNext;
5191 handleTypes = src->handleTypes;
5204 safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& src)
5206 sType = src.sType;
5207 pNext = src.pNext;
5208 handleTypes = src.handleTypes;
5222 void safe_VkExportMemoryAllocateInfoNV::initialize(const safe_VkExportMemoryAllocateInfoNV* src)
5224 sType = src->sType;
5225 pNext = src->pNext;
5226 handleTypes = src->handleTypes;
5241 safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& src)
5243 sType = src.sType;
5244 pNext = src.pNext;
5245 handleType = src.handleType;
5246 handle = src.handle;
5261 void safe_VkImportMemoryWin32HandleInfoNV::initialize(const safe_VkImportMemoryWin32HandleInfoNV* src)
5263 sType = src->sType;
5264 pNext = src->pNext;
5265 handleType = src->handleType;
5266 handle = src->handle;
5286 safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& src)
5288 sType = src.sType;
5289 pNext = src.pNext;
5291 dwAccess = src.dwAccess;
5292 if (src.pAttributes) {
5293 pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
5314 void safe_VkExportMemoryWin32HandleInfoNV::initialize(const safe_VkExportMemoryWin32HandleInfoNV* src)
5316 sType = src->sType;
5317 pNext = src->pNext;
5319 dwAccess = src->dwAccess;
5320 if (src->pAttributes) {
5321 pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
5372 safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& src)
5374 sType = src.sType;
5375 pNext = src.pNext;
5376 acquireCount = src.acquireCount;
5380 releaseCount = src.releaseCount;
5383 if (acquireCount && src.pAcquireSyncs) {
5386 pAcquireSyncs[i] = src.pAcquireSyncs[i];
5389 if (src.pAcquireKeys) {
5390 pAcquireKeys = new uint64_t[src.acquireCount];
5391 memcpy ((void *)pAcquireKeys, (void *)src.pAcquireKeys, sizeof(uint64_t)*src.acquireCount);
5393 if (src.pAcquireTimeoutMilliseconds) {
5394 pAcquireTimeoutMilliseconds = new uint32_t[src.acquireCount];
5395 memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)src.pAcquireTimeoutMilliseconds, sizeof(uint32_t)*src.acquireCount);
5397 if (releaseCount && src.pReleaseSyncs) {
5400 pReleaseSyncs[i] = src.pReleaseSyncs[i];
5403 if (src.pReleaseKeys) {
5404 pReleaseKeys = new uint64_t[src.releaseCount];
5405 memcpy ((void *)pReleaseKeys, (void *)src.pReleaseKeys, sizeof(uint64_t)*src.releaseCount);
5460 void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* src)
5462 sType = src->sType;
5463 pNext = src->pNext;
5464 acquireCount = src->acquireCount;
5468 releaseCount = src->releaseCount;
5471 if (acquireCount && src->pAcquireSyncs) {
5474 pAcquireSyncs[i] = src->pAcquireSyncs[i];
5477 if (src->pAcquireKeys) {
5478 pAcquireKeys = new uint64_t[src->acquireCount];
5479 memcpy ((void *)pAcquireKeys, (void *)src->pAcquireKeys, sizeof(uint64_t)*src->acquireCount);
5481 if (src->pAcquireTimeoutMilliseconds) {
5482 pAcquireTimeoutMilliseconds = new uint32_t[src->acquireCount];
5483 memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)src->pAcquireTimeoutMilliseconds, sizeof(uint32_t)*src->acquireCount);
5485 if (releaseCount && src->pReleaseSyncs) {
5488 pReleaseSyncs[i] = src->pReleaseSyncs[i];
5491 if (src->pReleaseKeys) {
5492 pReleaseKeys = new uint64_t[src->releaseCount];
5493 memcpy ((void *)pReleaseKeys, (void *)src->pReleaseKeys, sizeof(uint64_t)*src->releaseCount);
5513 safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& src)
5515 sType = src.sType;
5516 pNext = src.pNext;
5517 disabledValidationCheckCount = src.disabledValidationCheckCount;
5519 if (src.pDisabledValidationChecks) {
5520 pDisabledValidationChecks = new VkValidationCheckEXT(*src.pDisabledValidationChecks);
5541 void safe_VkValidationFlagsEXT::initialize(const safe_VkValidationFlagsEXT* src)
5543 sType = src->sType;
5544 pNext = src->pNext;
5545 disabledValidationCheckCount = src->disabledValidationCheckCount;
5547 if (src->pDisabledValidationChecks) {
5548 pDisabledValidationChecks = new VkValidationCheckEXT(*src->pDisabledValidationChecks);
