1/* THIS FILE IS GENERATED. DO NOT EDIT. */ 2 3/* 4 * Vulkan 5 * 6 * Copyright (c) 2015-2016 The Khronos Group Inc. 7 * Copyright (c) 2015-2016 Valve Corporation. 8 * Copyright (c) 2015-2016 LunarG, Inc. 9 * Copyright (c) 2015-2016 Google Inc. 10 * 11 * Licensed under the Apache License, Version 2.0 (the "License"); 12 * you may not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, 19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 * 23 * Author: Courtney Goeltzenleuchter <courtney@LunarG.com> 24 * Author: Tobin Ehlis <tobin@lunarg.com> 25 */ 26//#includes, #defines, globals and such... 27#include <vulkan/vulkan.h> 28#include <stdint.h> 29#include <stdio.h> 30#include <stdlib.h> 31#include <iostream> 32#include <sstream> 33#include <string> 34#include "vk_enum_string_helper.h" 35namespace StreamControl 36{ 37bool writeAddress = true; 38template <typename T> 39std::ostream& operator<< (std::ostream &out, T const* pointer) 40{ 41 if(writeAddress) 42 { 43 out.operator<<(pointer); 44 } 45 else 46 { 47 std::operator<<(out, "address"); 48 } 49 return out; 50} 51std::ostream& operator<<(std::ostream &out, char const*const s) 52{ 53 return std::operator<<(out, s); 54} 55} 56 57std::string dynamic_display(const void* pStruct, const std::string prefix); 58// CODEGEN : file ../vk_helper.py line #888 59std::string vk_print_vkallocationcallbacks(const VkAllocationCallbacks* pStruct, const std::string prefix); 60#ifdef VK_USE_PLATFORM_ANDROID_KHR 61std::string vk_print_vkandroidsurfacecreateinfokhr(const VkAndroidSurfaceCreateInfoKHR* pStruct, const std::string prefix); 62#endif //VK_USE_PLATFORM_ANDROID_KHR 63std::string vk_print_vkapplicationinfo(const VkApplicationInfo* pStruct, const std::string prefix); 64std::string vk_print_vkattachmentdescription(const VkAttachmentDescription* pStruct, const std::string prefix); 65std::string vk_print_vkattachmentreference(const VkAttachmentReference* pStruct, const std::string prefix); 66std::string vk_print_vkbindsparseinfo(const VkBindSparseInfo* pStruct, const std::string prefix); 67std::string vk_print_vkbuffercopy(const VkBufferCopy* pStruct, const std::string prefix); 68std::string vk_print_vkbuffercreateinfo(const VkBufferCreateInfo* pStruct, const std::string prefix); 69std::string vk_print_vkbufferimagecopy(const VkBufferImageCopy* pStruct, const std::string prefix); 70std::string vk_print_vkbuffermemorybarrier(const VkBufferMemoryBarrier* pStruct, const std::string prefix); 71std::string vk_print_vkbufferviewcreateinfo(const VkBufferViewCreateInfo* pStruct, const std::string prefix); 72std::string vk_print_vkclearattachment(const VkClearAttachment* pStruct, const std::string prefix); 73std::string vk_print_vkclearcolorvalue(const VkClearColorValue* pStruct, const std::string prefix); 74std::string vk_print_vkcleardepthstencilvalue(const VkClearDepthStencilValue* pStruct, const std::string prefix); 75std::string vk_print_vkclearrect(const VkClearRect* pStruct, const std::string prefix); 76std::string vk_print_vkclearvalue(const VkClearValue* pStruct, const std::string prefix); 77std::string vk_print_vkcommandbufferallocateinfo(const VkCommandBufferAllocateInfo* pStruct, const std::string prefix); 78std::string vk_print_vkcommandbufferbegininfo(const VkCommandBufferBeginInfo* pStruct, const std::string prefix); 79std::string vk_print_vkcommandbufferinheritanceinfo(const VkCommandBufferInheritanceInfo* pStruct, const std::string prefix); 80std::string vk_print_vkcommandpoolcreateinfo(const VkCommandPoolCreateInfo* pStruct, const std::string prefix); 81std::string vk_print_vkcomponentmapping(const VkComponentMapping* pStruct, const std::string prefix); 82std::string vk_print_vkcomputepipelinecreateinfo(const VkComputePipelineCreateInfo* pStruct, const std::string prefix); 83std::string vk_print_vkcopydescriptorset(const VkCopyDescriptorSet* pStruct, const std::string prefix); 84std::string vk_print_vkdebugmarkermarkerinfoext(const VkDebugMarkerMarkerInfoEXT* pStruct, const std::string prefix); 85std::string vk_print_vkdebugmarkerobjectnameinfoext(const VkDebugMarkerObjectNameInfoEXT* pStruct, const std::string prefix); 86std::string vk_print_vkdebugmarkerobjecttaginfoext(const VkDebugMarkerObjectTagInfoEXT* pStruct, const std::string prefix); 87std::string vk_print_vkdebugreportcallbackcreateinfoext(const VkDebugReportCallbackCreateInfoEXT* pStruct, const std::string prefix); 88std::string vk_print_vkdescriptorbufferinfo(const VkDescriptorBufferInfo* pStruct, const std::string prefix); 89std::string vk_print_vkdescriptorimageinfo(const VkDescriptorImageInfo* pStruct, const std::string prefix); 90std::string vk_print_vkdescriptorpoolcreateinfo(const VkDescriptorPoolCreateInfo* pStruct, const std::string prefix); 91std::string vk_print_vkdescriptorpoolsize(const VkDescriptorPoolSize* pStruct, const std::string prefix); 92std::string vk_print_vkdescriptorsetallocateinfo(const VkDescriptorSetAllocateInfo* pStruct, const std::string prefix); 93std::string vk_print_vkdescriptorsetlayoutbinding(const VkDescriptorSetLayoutBinding* pStruct, const std::string prefix); 94std::string vk_print_vkdescriptorsetlayoutcreateinfo(const VkDescriptorSetLayoutCreateInfo* pStruct, const std::string prefix); 95std::string vk_print_vkdevicecreateinfo(const VkDeviceCreateInfo* pStruct, const std::string prefix); 96std::string vk_print_vkdevicequeuecreateinfo(const VkDeviceQueueCreateInfo* pStruct, const std::string prefix); 97std::string vk_print_vkdispatchindirectcommand(const VkDispatchIndirectCommand* pStruct, const std::string prefix); 98std::string vk_print_vkdisplaymodecreateinfokhr(const VkDisplayModeCreateInfoKHR* pStruct, const std::string prefix); 99std::string vk_print_vkdisplaymodeparameterskhr(const VkDisplayModeParametersKHR* pStruct, const std::string prefix); 100std::string vk_print_vkdisplaymodepropertieskhr(const VkDisplayModePropertiesKHR* pStruct, const std::string prefix); 101std::string vk_print_vkdisplayplanecapabilitieskhr(const VkDisplayPlaneCapabilitiesKHR* pStruct, const std::string prefix); 102std::string vk_print_vkdisplayplanepropertieskhr(const VkDisplayPlanePropertiesKHR* pStruct, const std::string prefix); 103std::string vk_print_vkdisplaypresentinfokhr(const VkDisplayPresentInfoKHR* pStruct, const std::string prefix); 104std::string vk_print_vkdisplaypropertieskhr(const VkDisplayPropertiesKHR* pStruct, const std::string prefix); 105std::string vk_print_vkdisplaysurfacecreateinfokhr(const VkDisplaySurfaceCreateInfoKHR* pStruct, const std::string prefix); 106std::string vk_print_vkdrawindexedindirectcommand(const VkDrawIndexedIndirectCommand* pStruct, const std::string prefix); 107std::string vk_print_vkdrawindirectcommand(const VkDrawIndirectCommand* pStruct, const std::string prefix); 108std::string vk_print_vkeventcreateinfo(const VkEventCreateInfo* pStruct, const std::string prefix); 109std::string vk_print_vkextensionproperties(const VkExtensionProperties* pStruct, const std::string prefix); 110std::string vk_print_vkextent2d(const VkExtent2D* pStruct, const std::string prefix); 111std::string vk_print_vkextent3d(const VkExtent3D* pStruct, const std::string prefix); 112std::string vk_print_vkfencecreateinfo(const VkFenceCreateInfo* pStruct, const std::string prefix); 113std::string vk_print_vkformatproperties(const VkFormatProperties* pStruct, const std::string prefix); 114std::string vk_print_vkframebuffercreateinfo(const VkFramebufferCreateInfo* pStruct, const std::string prefix); 115std::string vk_print_vkgraphicspipelinecreateinfo(const VkGraphicsPipelineCreateInfo* pStruct, const std::string prefix); 116std::string vk_print_vkimageblit(const VkImageBlit* pStruct, const std::string prefix); 117std::string vk_print_vkimagecopy(const VkImageCopy* pStruct, const std::string prefix); 118std::string vk_print_vkimagecreateinfo(const VkImageCreateInfo* pStruct, const std::string prefix); 119std::string vk_print_vkimageformatproperties(const VkImageFormatProperties* pStruct, const std::string prefix); 120std::string vk_print_vkimagememorybarrier(const VkImageMemoryBarrier* pStruct, const std::string prefix); 121std::string vk_print_vkimageresolve(const VkImageResolve* pStruct, const std::string prefix); 122std::string vk_print_vkimagesubresource(const VkImageSubresource* pStruct, const std::string prefix); 123std::string vk_print_vkimagesubresourcelayers(const VkImageSubresourceLayers* pStruct, const std::string prefix); 124std::string vk_print_vkimagesubresourcerange(const VkImageSubresourceRange* pStruct, const std::string prefix); 125std::string vk_print_vkimageviewcreateinfo(const VkImageViewCreateInfo* pStruct, const std::string prefix); 126std::string vk_print_vkinstancecreateinfo(const VkInstanceCreateInfo* pStruct, const std::string prefix); 127std::string vk_print_vklayerproperties(const VkLayerProperties* pStruct, const std::string prefix); 128std::string vk_print_vkmappedmemoryrange(const VkMappedMemoryRange* pStruct, const std::string prefix); 129std::string vk_print_vkmemoryallocateinfo(const VkMemoryAllocateInfo* pStruct, const std::string prefix); 130std::string vk_print_vkmemorybarrier(const VkMemoryBarrier* pStruct, const std::string prefix); 131std::string vk_print_vkmemoryheap(const VkMemoryHeap* pStruct, const std::string prefix); 132std::string vk_print_vkmemoryrequirements(const VkMemoryRequirements* pStruct, const std::string prefix); 133std::string vk_print_vkmemorytype(const VkMemoryType* pStruct, const std::string prefix); 134#ifdef VK_USE_PLATFORM_MIR_KHR 135std::string vk_print_vkmirsurfacecreateinfokhr(const VkMirSurfaceCreateInfoKHR* pStruct, const std::string prefix); 136#endif //VK_USE_PLATFORM_MIR_KHR 137std::string vk_print_vkoffset2d(const VkOffset2D* pStruct, const std::string prefix); 138std::string vk_print_vkoffset3d(const VkOffset3D* pStruct, const std::string prefix); 139std::string vk_print_vkphysicaldevicefeatures(const VkPhysicalDeviceFeatures* pStruct, const std::string prefix); 140std::string vk_print_vkphysicaldevicelimits(const VkPhysicalDeviceLimits* pStruct, const std::string prefix); 141std::string vk_print_vkphysicaldevicememoryproperties(const VkPhysicalDeviceMemoryProperties* pStruct, const std::string prefix); 142std::string vk_print_vkphysicaldeviceproperties(const VkPhysicalDeviceProperties* pStruct, const std::string prefix); 143std::string vk_print_vkphysicaldevicesparseproperties(const VkPhysicalDeviceSparseProperties* pStruct, const std::string prefix); 144std::string vk_print_vkpipelinecachecreateinfo(const VkPipelineCacheCreateInfo* pStruct, const std::string prefix); 145std::string vk_print_vkpipelinecolorblendattachmentstate(const VkPipelineColorBlendAttachmentState* pStruct, const std::string prefix); 146std::string vk_print_vkpipelinecolorblendstatecreateinfo(const VkPipelineColorBlendStateCreateInfo* pStruct, const std::string prefix); 147std::string vk_print_vkpipelinedepthstencilstatecreateinfo(const VkPipelineDepthStencilStateCreateInfo* pStruct, const std::string prefix); 148std::string vk_print_vkpipelinedynamicstatecreateinfo(const VkPipelineDynamicStateCreateInfo* pStruct, const std::string prefix); 149std::string vk_print_vkpipelineinputassemblystatecreateinfo(const VkPipelineInputAssemblyStateCreateInfo* pStruct, const std::string prefix); 150std::string vk_print_vkpipelinelayoutcreateinfo(const VkPipelineLayoutCreateInfo* pStruct, const std::string prefix); 151std::string vk_print_vkpipelinemultisamplestatecreateinfo(const VkPipelineMultisampleStateCreateInfo* pStruct, const std::string prefix); 152std::string vk_print_vkpipelinerasterizationstatecreateinfo(const VkPipelineRasterizationStateCreateInfo* pStruct, const std::string prefix); 153std::string vk_print_vkpipelinerasterizationstaterasterizationorderamd(const VkPipelineRasterizationStateRasterizationOrderAMD* pStruct, const std::string prefix); 154std::string vk_print_vkpipelineshaderstagecreateinfo(const VkPipelineShaderStageCreateInfo* pStruct, const std::string prefix); 155std::string vk_print_vkpipelinetessellationstatecreateinfo(const VkPipelineTessellationStateCreateInfo* pStruct, const std::string prefix); 156std::string vk_print_vkpipelinevertexinputstatecreateinfo(const VkPipelineVertexInputStateCreateInfo* pStruct, const std::string prefix); 157std::string vk_print_vkpipelineviewportstatecreateinfo(const VkPipelineViewportStateCreateInfo* pStruct, const std::string prefix); 158std::string vk_print_vkpresentinfokhr(const VkPresentInfoKHR* pStruct, const std::string prefix); 159std::string vk_print_vkpushconstantrange(const VkPushConstantRange* pStruct, const std::string prefix); 160std::string vk_print_vkquerypoolcreateinfo(const VkQueryPoolCreateInfo* pStruct, const std::string prefix); 161std::string vk_print_vkqueuefamilyproperties(const VkQueueFamilyProperties* pStruct, const std::string prefix); 162std::string vk_print_vkrect2d(const VkRect2D* pStruct, const std::string prefix); 163std::string vk_print_vkrenderpassbegininfo(const VkRenderPassBeginInfo* pStruct, const std::string prefix); 164std::string vk_print_vkrenderpasscreateinfo(const VkRenderPassCreateInfo* pStruct, const std::string prefix); 165std::string vk_print_vksamplercreateinfo(const VkSamplerCreateInfo* pStruct, const std::string prefix); 166std::string vk_print_vksemaphorecreateinfo(const VkSemaphoreCreateInfo* pStruct, const std::string prefix); 167std::string vk_print_vkshadermodulecreateinfo(const VkShaderModuleCreateInfo* pStruct, const std::string prefix); 168std::string vk_print_vksparsebuffermemorybindinfo(const VkSparseBufferMemoryBindInfo* pStruct, const std::string prefix); 169std::string vk_print_vksparseimageformatproperties(const VkSparseImageFormatProperties* pStruct, const std::string prefix); 170std::string vk_print_vksparseimagememorybind(const VkSparseImageMemoryBind* pStruct, const std::string prefix); 171std::string vk_print_vksparseimagememorybindinfo(const VkSparseImageMemoryBindInfo* pStruct, const std::string prefix); 172std::string vk_print_vksparseimagememoryrequirements(const VkSparseImageMemoryRequirements* pStruct, const std::string prefix); 173std::string vk_print_vksparseimageopaquememorybindinfo(const VkSparseImageOpaqueMemoryBindInfo* pStruct, const std::string prefix); 174std::string vk_print_vksparsememorybind(const VkSparseMemoryBind* pStruct, const std::string prefix); 175std::string vk_print_vkspecializationinfo(const VkSpecializationInfo* pStruct, const std::string prefix); 176std::string vk_print_vkspecializationmapentry(const VkSpecializationMapEntry* pStruct, const std::string prefix); 177std::string vk_print_vkstencilopstate(const VkStencilOpState* pStruct, const std::string prefix); 178std::string vk_print_vksubmitinfo(const VkSubmitInfo* pStruct, const std::string prefix); 179std::string vk_print_vksubpassdependency(const VkSubpassDependency* pStruct, const std::string prefix); 180std::string vk_print_vksubpassdescription(const VkSubpassDescription* pStruct, const std::string prefix); 181std::string vk_print_vksubresourcelayout(const VkSubresourceLayout* pStruct, const std::string prefix); 182std::string vk_print_vksurfacecapabilitieskhr(const VkSurfaceCapabilitiesKHR* pStruct, const std::string prefix); 183std::string vk_print_vksurfaceformatkhr(const VkSurfaceFormatKHR* pStruct, const std::string prefix); 184std::string vk_print_vkswapchaincreateinfokhr(const VkSwapchainCreateInfoKHR* pStruct, const std::string prefix); 185std::string vk_print_vkvertexinputattributedescription(const VkVertexInputAttributeDescription* pStruct, const std::string prefix); 186std::string vk_print_vkvertexinputbindingdescription(const VkVertexInputBindingDescription* pStruct, const std::string prefix); 187std::string vk_print_vkviewport(const VkViewport* pStruct, const std::string prefix); 188#ifdef VK_USE_PLATFORM_WAYLAND_KHR 189std::string vk_print_vkwaylandsurfacecreateinfokhr(const VkWaylandSurfaceCreateInfoKHR* pStruct, const std::string prefix); 190#endif //VK_USE_PLATFORM_WAYLAND_KHR 191#ifdef VK_USE_PLATFORM_WIN32_KHR 192std::string vk_print_vkwin32surfacecreateinfokhr(const VkWin32SurfaceCreateInfoKHR* pStruct, const std::string prefix); 193#endif //VK_USE_PLATFORM_WIN32_KHR 194std::string vk_print_vkwritedescriptorset(const VkWriteDescriptorSet* pStruct, const std::string prefix); 195#ifdef VK_USE_PLATFORM_XCB_KHR 196std::string vk_print_vkxcbsurfacecreateinfokhr(const VkXcbSurfaceCreateInfoKHR* pStruct, const std::string prefix); 197#endif //VK_USE_PLATFORM_XCB_KHR 198#ifdef VK_USE_PLATFORM_XLIB_KHR 199std::string vk_print_vkxlibsurfacecreateinfokhr(const VkXlibSurfaceCreateInfoKHR* pStruct, const std::string prefix); 200#endif //VK_USE_PLATFORM_XLIB_KHR 201 202 203// CODEGEN : file ../vk_helper.py line #896 204// CODEGEN : file ../vk_helper.py line #906 205std::string vk_print_vkallocationcallbacks(const VkAllocationCallbacks* pStruct, const std::string prefix) 206{ 207// CODEGEN : file ../vk_helper.py line #912 208 using namespace StreamControl; 209 using namespace std; 210 string final_str; 211 string tmp_str; 212 string extra_indent = " " + prefix; 213 stringstream ss[6]; 214// CODEGEN : file ../vk_helper.py line #1069 215 if (StreamControl::writeAddress) 216 ss[0] << "0x" << pStruct->pUserData; 217 else 218 ss[0].str("address"); 219// CODEGEN : file ../vk_helper.py line #1085 220 ss[1] << "0x" << pStruct->pfnAllocation; 221// CODEGEN : file ../vk_helper.py line #1085 222 ss[2] << "0x" << pStruct->pfnReallocation; 223// CODEGEN : file ../vk_helper.py line #1085 224 ss[3] << "0x" << pStruct->pfnFree; 225// CODEGEN : file ../vk_helper.py line #1085 226 ss[4] << "0x" << pStruct->pfnInternalAllocation; 227// CODEGEN : file ../vk_helper.py line #1085 228 ss[5] << "0x" << pStruct->pfnInternalFree; 229// CODEGEN : file ../vk_helper.py line #1113 230 final_str = prefix + "pUserData = " + ss[0].str() + "\n" + prefix + "pfnAllocation = " + ss[1].str() + "\n" + prefix + "pfnReallocation = " + ss[2].str() + "\n" + prefix + "pfnFree = " + ss[3].str() + "\n" + prefix + "pfnInternalAllocation = " + ss[4].str() + "\n" + prefix + "pfnInternalFree = " + ss[5].str() + "\n"; 231 return final_str; 232} 233// CODEGEN : file ../vk_helper.py line #906 234#ifdef VK_USE_PLATFORM_ANDROID_KHR 235std::string vk_print_vkandroidsurfacecreateinfokhr(const VkAndroidSurfaceCreateInfoKHR* pStruct, const std::string prefix) 236{ 237// CODEGEN : file ../vk_helper.py line #912 238 using namespace StreamControl; 239 using namespace std; 240 string final_str; 241 string tmp_str; 242 string extra_indent = " " + prefix; 243 stringstream ss[3]; 244 string stp_strs[1]; 245// CODEGEN : file ../vk_helper.py line #1011 246 if (pStruct->pNext) { 247// CODEGEN : file ../vk_helper.py line #1015 248 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 249 ss[0] << "0x" << &pStruct->pNext; 250// CODEGEN : file ../vk_helper.py line #1027 251 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 252 ss[0].str(""); 253 } 254 else 255 stp_strs[0] = ""; 256// CODEGEN : file ../vk_helper.py line #1069 257 if (StreamControl::writeAddress) 258 ss[0] << "0x" << pStruct->pNext; 259 else 260 ss[0].str("address"); 261// CODEGEN : file ../vk_helper.py line #1085 262 ss[1] << "0x" << pStruct->flags; 263// CODEGEN : file ../vk_helper.py line #1085 264 ss[2] << "0x" << pStruct->window; 265// CODEGEN : file ../vk_helper.py line #1113 266 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "window = " + ss[2].str() + "\n" + stp_strs[0]; 267 return final_str; 268} 269#endif //VK_USE_PLATFORM_ANDROID_KHR 270// CODEGEN : file ../vk_helper.py line #906 271std::string vk_print_vkapplicationinfo(const VkApplicationInfo* pStruct, const std::string prefix) 272{ 273// CODEGEN : file ../vk_helper.py line #912 274 using namespace StreamControl; 275 using namespace std; 276 string final_str; 277 string tmp_str; 278 string extra_indent = " " + prefix; 279 stringstream ss[6]; 280 string stp_strs[1]; 281// CODEGEN : file ../vk_helper.py line #1011 282 if (pStruct->pNext) { 283// CODEGEN : file ../vk_helper.py line #1015 284 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 285 ss[0] << "0x" << &pStruct->pNext; 286// CODEGEN : file ../vk_helper.py line #1027 287 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 288 ss[0].str(""); 289 } 290 else 291 stp_strs[0] = ""; 292// CODEGEN : file ../vk_helper.py line #1069 293 if (StreamControl::writeAddress) 294 ss[0] << "0x" << pStruct->pNext; 295 else 296 ss[0].str("address"); 297// CODEGEN : file ../vk_helper.py line #1075 298 if (pStruct->pApplicationName != NULL) { 299 ss[1] << pStruct->pApplicationName; 300 } else { 301 ss[1] << ""; 302 } 303// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 304 ss[2] << pStruct->applicationVersion; 305// CODEGEN : file ../vk_helper.py line #1075 306 if (pStruct->pEngineName != NULL) { 307 ss[3] << pStruct->pEngineName; 308 } else { 309 ss[3] << ""; 310 } 311// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 312 ss[4] << pStruct->engineVersion; 313// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 314 ss[5] << pStruct->apiVersion; 315// CODEGEN : file ../vk_helper.py line #1113 316 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "pApplicationName = " + ss[1].str() + "\n" + prefix + "applicationVersion = " + ss[2].str() + "\n" + prefix + "pEngineName = " + ss[3].str() + "\n" + prefix + "engineVersion = " + ss[4].str() + "\n" + prefix + "apiVersion = " + ss[5].str() + "\n" + stp_strs[0]; 317 return final_str; 318} 319// CODEGEN : file ../vk_helper.py line #906 320std::string vk_print_vkattachmentdescription(const VkAttachmentDescription* pStruct, const std::string prefix) 321{ 322// CODEGEN : file ../vk_helper.py line #912 323 using namespace StreamControl; 324 using namespace std; 325 string final_str; 326 string tmp_str; 327 string extra_indent = " " + prefix; 328 stringstream ss[1]; 329// CODEGEN : file ../vk_helper.py line #1085 330 ss[0] << "0x" << pStruct->flags; 331// CODEGEN : file ../vk_helper.py line #1113 332 final_str = prefix + "flags = " + ss[0].str() + "\n" + prefix + "format = " + string_VkFormat(pStruct->format) + "\n" + prefix + "samples = " + string_VkSampleCountFlagBits(pStruct->samples) + "\n" + prefix + "loadOp = " + string_VkAttachmentLoadOp(pStruct->loadOp) + "\n" + prefix + "storeOp = " + string_VkAttachmentStoreOp(pStruct->storeOp) + "\n" + prefix + "stencilLoadOp = " + string_VkAttachmentLoadOp(pStruct->stencilLoadOp) + "\n" + prefix + "stencilStoreOp = " + string_VkAttachmentStoreOp(pStruct->stencilStoreOp) + "\n" + prefix + "initialLayout = " + string_VkImageLayout(pStruct->initialLayout) + "\n" + prefix + "finalLayout = " + string_VkImageLayout(pStruct->finalLayout) + "\n"; 333 return final_str; 334} 335// CODEGEN : file ../vk_helper.py line #906 336std::string vk_print_vkattachmentreference(const VkAttachmentReference* pStruct, const std::string prefix) 337{ 338// CODEGEN : file ../vk_helper.py line #912 339 using namespace StreamControl; 340 using namespace std; 341 string final_str; 342 string tmp_str; 343 string extra_indent = " " + prefix; 344 stringstream ss[1]; 345// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 346 ss[0] << pStruct->attachment; 347// CODEGEN : file ../vk_helper.py line #1113 348 final_str = prefix + "attachment = " + ss[0].str() + "\n" + prefix + "layout = " + string_VkImageLayout(pStruct->layout) + "\n"; 349 return final_str; 350} 351// CODEGEN : file ../vk_helper.py line #906 352std::string vk_print_vkbindsparseinfo(const VkBindSparseInfo* pStruct, const std::string prefix) 353{ 354// CODEGEN : file ../vk_helper.py line #912 355 using namespace StreamControl; 356 using namespace std; 357 string final_str; 358 string tmp_str; 359 string extra_indent = " " + prefix; 360 stringstream ss[11]; 361 string stp_strs[6]; 362// CODEGEN : file ../vk_helper.py line #1011 363 if (pStruct->pNext) { 364// CODEGEN : file ../vk_helper.py line #1015 365 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 366 ss[0] << "0x" << &pStruct->pNext; 367// CODEGEN : file ../vk_helper.py line #1027 368 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 369 ss[0].str(""); 370 } 371 else 372 stp_strs[0] = ""; 373// CODEGEN : file ../vk_helper.py line #931 374// CODEGEN : file ../vk_helper.py line #933 375// CODEGEN : file ../vk_helper.py line #938 376 stp_strs[1] = ""; 377 stringstream index_ss; 378 if (pStruct->pWaitSemaphores) { 379 for (uint32_t i = 0; i < pStruct->waitSemaphoreCount; i++) { 380 index_ss.str(""); 381 index_ss << i; 382// CODEGEN : file ../vk_helper.py line #989 383 ss[1] << "0x" << pStruct->pWaitSemaphores[i]; 384 stp_strs[1] += " " + prefix + "pWaitSemaphores[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 385// CODEGEN : file ../vk_helper.py line #999 386 ss[1].str(""); 387 } 388 } 389// CODEGEN : file ../vk_helper.py line #931 390// CODEGEN : file ../vk_helper.py line #933 391// CODEGEN : file ../vk_helper.py line #938 392 stp_strs[2] = ""; 393 if (pStruct->pBufferBinds) { 394 for (uint32_t i = 0; i < pStruct->bufferBindCount; i++) { 395 index_ss.str(""); 396 index_ss << i; 397// CODEGEN : file ../vk_helper.py line #979 398 ss[2] << "0x" << &pStruct->pBufferBinds[i]; 399 tmp_str = vk_print_vksparsebuffermemorybindinfo(&pStruct->pBufferBinds[i], extra_indent); 400// CODEGEN : file ../vk_helper.py line #983 401 stp_strs[2] += " " + prefix + "pBufferBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 402// CODEGEN : file ../vk_helper.py line #999 403 ss[2].str(""); 404 } 405 } 406// CODEGEN : file ../vk_helper.py line #931 407// CODEGEN : file ../vk_helper.py line #933 408// CODEGEN : file ../vk_helper.py line #938 409 stp_strs[3] = ""; 410 if (pStruct->pImageOpaqueBinds) { 411 for (uint32_t i = 0; i < pStruct->imageOpaqueBindCount; i++) { 412 index_ss.str(""); 413 index_ss << i; 414// CODEGEN : file ../vk_helper.py line #979 415 ss[3] << "0x" << &pStruct->pImageOpaqueBinds[i]; 416 tmp_str = vk_print_vksparseimageopaquememorybindinfo(&pStruct->pImageOpaqueBinds[i], extra_indent); 417// CODEGEN : file ../vk_helper.py line #983 418 stp_strs[3] += " " + prefix + "pImageOpaqueBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 419// CODEGEN : file ../vk_helper.py line #999 420 ss[3].str(""); 421 } 422 } 423// CODEGEN : file ../vk_helper.py line #931 424// CODEGEN : file ../vk_helper.py line #933 425// CODEGEN : file ../vk_helper.py line #938 426 stp_strs[4] = ""; 427 if (pStruct->pImageBinds) { 428 for (uint32_t i = 0; i < pStruct->imageBindCount; i++) { 429 index_ss.str(""); 430 index_ss << i; 431// CODEGEN : file ../vk_helper.py line #979 432 ss[4] << "0x" << &pStruct->pImageBinds[i]; 433 tmp_str = vk_print_vksparseimagememorybindinfo(&pStruct->pImageBinds[i], extra_indent); 434// CODEGEN : file ../vk_helper.py line #983 435 stp_strs[4] += " " + prefix + "pImageBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 436// CODEGEN : file ../vk_helper.py line #999 437 ss[4].str(""); 438 } 439 } 440// CODEGEN : file ../vk_helper.py line #931 441// CODEGEN : file ../vk_helper.py line #933 442// CODEGEN : file ../vk_helper.py line #938 443 stp_strs[5] = ""; 444 if (pStruct->pSignalSemaphores) { 445 for (uint32_t i = 0; i < pStruct->signalSemaphoreCount; i++) { 446 index_ss.str(""); 447 index_ss << i; 448// CODEGEN : file ../vk_helper.py line #989 449 ss[5] << "0x" << pStruct->pSignalSemaphores[i]; 450 stp_strs[5] += " " + prefix + "pSignalSemaphores[" + index_ss.str() + "].handle = " + ss[5].str() + "\n"; 451// CODEGEN : file ../vk_helper.py line #999 452 ss[5].str(""); 453 } 454 } 455// CODEGEN : file ../vk_helper.py line #1069 456 if (StreamControl::writeAddress) 457 ss[0] << "0x" << pStruct->pNext; 458 else 459 ss[0].str("address"); 460// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 461 ss[1] << pStruct->waitSemaphoreCount; 462// CODEGEN : file ../vk_helper.py line #1060 463 ss[2] << "0x" << (void*)pStruct->pWaitSemaphores; 464// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 465 ss[3] << "0x" << pStruct->bufferBindCount; 466// CODEGEN : file ../vk_helper.py line #1060 467 ss[4] << "0x" << (void*)pStruct->pBufferBinds; 468// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 469 ss[5] << pStruct->imageOpaqueBindCount; 470// CODEGEN : file ../vk_helper.py line #1060 471 ss[6] << "0x" << (void*)pStruct->pImageOpaqueBinds; 472// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 473 ss[7] << pStruct->imageBindCount; 474// CODEGEN : file ../vk_helper.py line #1060 475 ss[8] << "0x" << (void*)pStruct->pImageBinds; 476// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 477 ss[9] << pStruct->signalSemaphoreCount; 478// CODEGEN : file ../vk_helper.py line #1060 479 ss[10] << "0x" << (void*)pStruct->pSignalSemaphores; 480// CODEGEN : file ../vk_helper.py line #1113 481 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "waitSemaphoreCount = " + ss[1].str() + "\n" + prefix + "pWaitSemaphores = " + ss[2].str() + "\n" + prefix + "bufferBindCount = " + ss[3].str() + "\n" + prefix + "pBufferBinds = " + ss[4].str() + "\n" + prefix + "imageOpaqueBindCount = " + ss[5].str() + "\n" + prefix + "pImageOpaqueBinds = " + ss[6].str() + "\n" + prefix + "imageBindCount = " + ss[7].str() + "\n" + prefix + "pImageBinds = " + ss[8].str() + "\n" + prefix + "signalSemaphoreCount = " + ss[9].str() + "\n" + prefix + "pSignalSemaphores = " + ss[10].str() + "\n" + stp_strs[5] + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 482 return final_str; 483} 484// CODEGEN : file ../vk_helper.py line #906 485std::string vk_print_vkbuffercopy(const VkBufferCopy* pStruct, const std::string prefix) 486{ 487// CODEGEN : file ../vk_helper.py line #912 488 using namespace StreamControl; 489 using namespace std; 490 string final_str; 491 string tmp_str; 492 string extra_indent = " " + prefix; 493 stringstream ss[3]; 494// CODEGEN : file ../vk_helper.py line #1085 495 ss[0] << "0x" << pStruct->srcOffset; 496// CODEGEN : file ../vk_helper.py line #1085 497 ss[1] << "0x" << pStruct->dstOffset; 498// CODEGEN : file ../vk_helper.py line #1085 499 ss[2] << "0x" << pStruct->size; 500// CODEGEN : file ../vk_helper.py line #1113 501 final_str = prefix + "srcOffset = " + ss[0].str() + "\n" + prefix + "dstOffset = " + ss[1].str() + "\n" + prefix + "size = " + ss[2].str() + "\n"; 502 return final_str; 503} 504// CODEGEN : file ../vk_helper.py line #906 505std::string vk_print_vkbuffercreateinfo(const VkBufferCreateInfo* pStruct, const std::string prefix) 506{ 507// CODEGEN : file ../vk_helper.py line #912 508 using namespace StreamControl; 509 using namespace std; 510 string final_str; 511 string tmp_str; 512 string extra_indent = " " + prefix; 513 stringstream ss[6]; 514 string stp_strs[2]; 515// CODEGEN : file ../vk_helper.py line #1011 516 if (pStruct->pNext) { 517// CODEGEN : file ../vk_helper.py line #1015 518 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 519 ss[0] << "0x" << &pStruct->pNext; 520// CODEGEN : file ../vk_helper.py line #1027 521 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 522 ss[0].str(""); 523 } 524 else 525 stp_strs[0] = ""; 526// CODEGEN : file ../vk_helper.py line #931 527// CODEGEN : file ../vk_helper.py line #933 528// CODEGEN : file ../vk_helper.py line #938 529 stp_strs[1] = ""; 530 stringstream index_ss; 531 if (pStruct->sharingMode == VK_SHARING_MODE_CONCURRENT) { 532 if (pStruct->pQueueFamilyIndices) { 533 for (uint32_t i = 0; i < pStruct->queueFamilyIndexCount; i++) { 534 index_ss.str(""); 535 index_ss << i; 536// CODEGEN : file ../vk_helper.py line #989 537 ss[1] << "0x" << pStruct->pQueueFamilyIndices[i]; 538 stp_strs[1] += " " + prefix + "pQueueFamilyIndices[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 539// CODEGEN : file ../vk_helper.py line #999 540 ss[1].str(""); 541 } 542 } 543 } 544// CODEGEN : file ../vk_helper.py line #1069 545 if (StreamControl::writeAddress) 546 ss[0] << "0x" << pStruct->pNext; 547 else 548 ss[0].str("address"); 549// CODEGEN : file ../vk_helper.py line #1085 550 ss[1] << "0x" << pStruct->flags; 551// CODEGEN : file ../vk_helper.py line #1085 552 ss[2] << "0x" << pStruct->size; 553// CODEGEN : file ../vk_helper.py line #1085 554 ss[3] << "0x" << pStruct->usage; 555// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 556 ss[4] << pStruct->queueFamilyIndexCount; 557// CODEGEN : file ../vk_helper.py line #1060 558 ss[5] << "0x" << (void*)pStruct->pQueueFamilyIndices; 559// CODEGEN : file ../vk_helper.py line #1113 560 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "size = " + ss[2].str() + "\n" + prefix + "usage = " + ss[3].str() + "\n" + prefix + "sharingMode = " + string_VkSharingMode(pStruct->sharingMode) + "\n" + prefix + "queueFamilyIndexCount = " + ss[4].str() + "\n" + prefix + "pQueueFamilyIndices = " + ss[5].str() + "\n" + stp_strs[1] + stp_strs[0]; 561 return final_str; 562} 563// CODEGEN : file ../vk_helper.py line #906 564std::string vk_print_vkbufferimagecopy(const VkBufferImageCopy* pStruct, const std::string prefix) 565{ 566// CODEGEN : file ../vk_helper.py line #912 567 using namespace StreamControl; 568 using namespace std; 569 string final_str; 570 string tmp_str; 571 string extra_indent = " " + prefix; 572 stringstream ss[6]; 573 string stp_strs[3]; 574// CODEGEN : file ../vk_helper.py line #1037 575 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->imageSubresource, extra_indent); 576 ss[0] << "0x" << &pStruct->imageSubresource; 577 stp_strs[0] = " " + prefix + "imageSubresource (addr)\n" + tmp_str; 578// CODEGEN : file ../vk_helper.py line #1042 579 ss[0].str(""); 580// CODEGEN : file ../vk_helper.py line #1037 581 tmp_str = vk_print_vkoffset3d(&pStruct->imageOffset, extra_indent); 582 ss[1] << "0x" << &pStruct->imageOffset; 583 stp_strs[1] = " " + prefix + "imageOffset (addr)\n" + tmp_str; 584// CODEGEN : file ../vk_helper.py line #1042 585 ss[1].str(""); 586// CODEGEN : file ../vk_helper.py line #1037 587 tmp_str = vk_print_vkextent3d(&pStruct->imageExtent, extra_indent); 588 ss[2] << "0x" << &pStruct->imageExtent; 589 stp_strs[2] = " " + prefix + "imageExtent (addr)\n" + tmp_str; 590// CODEGEN : file ../vk_helper.py line #1042 591 ss[2].str(""); 592// CODEGEN : file ../vk_helper.py line #1085 593 ss[0] << "0x" << pStruct->bufferOffset; 594// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 595 ss[1] << "0x" << pStruct->bufferRowLength; 596// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 597 ss[2] << "0x" << pStruct->bufferImageHeight; 598// CODEGEN : file ../vk_helper.py line #1054 599 ss[3].str("addr"); 600// CODEGEN : file ../vk_helper.py line #1054 601 ss[4].str("addr"); 602// CODEGEN : file ../vk_helper.py line #1054 603 ss[5].str("addr"); 604// CODEGEN : file ../vk_helper.py line #1113 605 final_str = prefix + "bufferOffset = " + ss[0].str() + "\n" + prefix + "bufferRowLength = " + ss[1].str() + "\n" + prefix + "bufferImageHeight = " + ss[2].str() + "\n" + prefix + "imageSubresource = " + ss[3].str() + "\n" + prefix + "imageOffset = " + ss[4].str() + "\n" + prefix + "imageExtent = " + ss[5].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 606 return final_str; 607} 608// CODEGEN : file ../vk_helper.py line #906 609std::string vk_print_vkbuffermemorybarrier(const VkBufferMemoryBarrier* pStruct, const std::string prefix) 610{ 611// CODEGEN : file ../vk_helper.py line #912 612 using namespace StreamControl; 613 using namespace std; 614 string final_str; 615 string tmp_str; 616 string extra_indent = " " + prefix; 617 stringstream ss[8]; 618 string stp_strs[1]; 619// CODEGEN : file ../vk_helper.py line #1011 620 if (pStruct->pNext) { 621// CODEGEN : file ../vk_helper.py line #1015 622 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 623 ss[0] << "0x" << &pStruct->pNext; 624// CODEGEN : file ../vk_helper.py line #1027 625 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 626 ss[0].str(""); 627 } 628 else 629 stp_strs[0] = ""; 630// CODEGEN : file ../vk_helper.py line #1069 631 if (StreamControl::writeAddress) 632 ss[0] << "0x" << pStruct->pNext; 633 else 634 ss[0].str("address"); 635// CODEGEN : file ../vk_helper.py line #1085 636 ss[1] << "0x" << pStruct->srcAccessMask; 637// CODEGEN : file ../vk_helper.py line #1085 638 ss[2] << "0x" << pStruct->dstAccessMask; 639// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 640 ss[3] << pStruct->srcQueueFamilyIndex; 641// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 642 ss[4] << pStruct->dstQueueFamilyIndex; 643// CODEGEN : file ../vk_helper.py line #1085 644 ss[5] << "0x" << pStruct->buffer; 645// CODEGEN : file ../vk_helper.py line #1085 646 ss[6] << "0x" << pStruct->offset; 647// CODEGEN : file ../vk_helper.py line #1085 648 ss[7] << "0x" << pStruct->size; 649// CODEGEN : file ../vk_helper.py line #1113 650 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "srcAccessMask = " + ss[1].str() + "\n" + prefix + "dstAccessMask = " + ss[2].str() + "\n" + prefix + "srcQueueFamilyIndex = " + ss[3].str() + "\n" + prefix + "dstQueueFamilyIndex = " + ss[4].str() + "\n" + prefix + "buffer = " + ss[5].str() + "\n" + prefix + "offset = " + ss[6].str() + "\n" + prefix + "size = " + ss[7].str() + "\n" + stp_strs[0]; 651 return final_str; 652} 653// CODEGEN : file ../vk_helper.py line #906 654std::string vk_print_vkbufferviewcreateinfo(const VkBufferViewCreateInfo* pStruct, const std::string prefix) 655{ 656// CODEGEN : file ../vk_helper.py line #912 657 using namespace StreamControl; 658 using namespace std; 659 string final_str; 660 string tmp_str; 661 string extra_indent = " " + prefix; 662 stringstream ss[5]; 663 string stp_strs[1]; 664// CODEGEN : file ../vk_helper.py line #1011 665 if (pStruct->pNext) { 666// CODEGEN : file ../vk_helper.py line #1015 667 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 668 ss[0] << "0x" << &pStruct->pNext; 669// CODEGEN : file ../vk_helper.py line #1027 670 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 671 ss[0].str(""); 672 } 673 else 674 stp_strs[0] = ""; 675// CODEGEN : file ../vk_helper.py line #1069 676 if (StreamControl::writeAddress) 677 ss[0] << "0x" << pStruct->pNext; 678 else 679 ss[0].str("address"); 680// CODEGEN : file ../vk_helper.py line #1085 681 ss[1] << "0x" << pStruct->flags; 682// CODEGEN : file ../vk_helper.py line #1085 683 ss[2] << "0x" << pStruct->buffer; 684// CODEGEN : file ../vk_helper.py line #1085 685 ss[3] << "0x" << pStruct->offset; 686// CODEGEN : file ../vk_helper.py line #1085 687 ss[4] << "0x" << pStruct->range; 688// CODEGEN : file ../vk_helper.py line #1113 689 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "buffer = " + ss[2].str() + "\n" + prefix + "format = " + string_VkFormat(pStruct->format) + "\n" + prefix + "offset = " + ss[3].str() + "\n" + prefix + "range = " + ss[4].str() + "\n" + stp_strs[0]; 690 return final_str; 691} 692// CODEGEN : file ../vk_helper.py line #906 693std::string vk_print_vkclearattachment(const VkClearAttachment* pStruct, const std::string prefix) 694{ 695// CODEGEN : file ../vk_helper.py line #912 696 using namespace StreamControl; 697 using namespace std; 698 string final_str; 699 string tmp_str; 700 string extra_indent = " " + prefix; 701 stringstream ss[3]; 702 string stp_strs[1]; 703// CODEGEN : file ../vk_helper.py line #1037 704 tmp_str = vk_print_vkclearvalue(&pStruct->clearValue, extra_indent); 705 ss[0] << "0x" << &pStruct->clearValue; 706 stp_strs[0] = " " + prefix + "clearValue (addr)\n" + tmp_str; 707// CODEGEN : file ../vk_helper.py line #1042 708 ss[0].str(""); 709// CODEGEN : file ../vk_helper.py line #1085 710 ss[0] << "0x" << pStruct->aspectMask; 711// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 712 ss[1] << pStruct->colorAttachment; 713// CODEGEN : file ../vk_helper.py line #1054 714 ss[2].str("addr"); 715// CODEGEN : file ../vk_helper.py line #1113 716 final_str = prefix + "aspectMask = " + ss[0].str() + "\n" + prefix + "colorAttachment = " + ss[1].str() + "\n" + prefix + "clearValue = " + ss[2].str() + "\n" + stp_strs[0]; 717 return final_str; 718} 719// CODEGEN : file ../vk_helper.py line #906 720std::string vk_print_vkclearcolorvalue(const VkClearColorValue* pStruct, const std::string prefix) 721{ 722// CODEGEN : file ../vk_helper.py line #912 723 using namespace StreamControl; 724 using namespace std; 725 string final_str; 726 string tmp_str; 727 string extra_indent = " " + prefix; 728 stringstream ss[3]; 729 string stp_strs[3]; 730// CODEGEN : file ../vk_helper.py line #931 731// CODEGEN : file ../vk_helper.py line #936 732// CODEGEN : file ../vk_helper.py line #938 733 stp_strs[0] = ""; 734 stringstream index_ss; 735 for (uint32_t i = 0; i < 4; i++) { 736 index_ss.str(""); 737 index_ss << i; 738// CODEGEN : file ../vk_helper.py line #989 739 ss[0] << pStruct->float32[i]; 740 stp_strs[0] += " " + prefix + "float32[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 741// CODEGEN : file ../vk_helper.py line #999 742 ss[0].str(""); 743 } 744// CODEGEN : file ../vk_helper.py line #931 745// CODEGEN : file ../vk_helper.py line #936 746// CODEGEN : file ../vk_helper.py line #938 747 stp_strs[1] = ""; 748 for (uint32_t i = 0; i < 4; i++) { 749 index_ss.str(""); 750 index_ss << i; 751// CODEGEN : file ../vk_helper.py line #989 752 ss[1] << pStruct->int32[i]; 753 stp_strs[1] += " " + prefix + "int32[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 754// CODEGEN : file ../vk_helper.py line #999 755 ss[1].str(""); 756 } 757// CODEGEN : file ../vk_helper.py line #931 758// CODEGEN : file ../vk_helper.py line #936 759// CODEGEN : file ../vk_helper.py line #938 760 stp_strs[2] = ""; 761 for (uint32_t i = 0; i < 4; i++) { 762 index_ss.str(""); 763 index_ss << i; 764// CODEGEN : file ../vk_helper.py line #989 765 ss[2] << pStruct->uint32[i]; 766 stp_strs[2] += " " + prefix + "uint32[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 767// CODEGEN : file ../vk_helper.py line #999 768 ss[2].str(""); 769 } 770// CODEGEN : file ../vk_helper.py line #1060 771 ss[0] << "0x" << (void*)pStruct->float32; 772// CODEGEN : file ../vk_helper.py line #1060 773 ss[1] << "0x" << (void*)pStruct->int32; 774// CODEGEN : file ../vk_helper.py line #1060 775 ss[2] << "0x" << (void*)pStruct->uint32; 776// CODEGEN : file ../vk_helper.py line #1113 777 final_str = prefix + "float32 = " + ss[0].str() + "\n" + prefix + "int32 = " + ss[1].str() + "\n" + prefix + "uint32 = " + ss[2].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 778 return final_str; 779} 780// CODEGEN : file ../vk_helper.py line #906 781std::string vk_print_vkcleardepthstencilvalue(const VkClearDepthStencilValue* pStruct, const std::string prefix) 782{ 783// CODEGEN : file ../vk_helper.py line #912 784 using namespace StreamControl; 785 using namespace std; 786 string final_str; 787 string tmp_str; 788 string extra_indent = " " + prefix; 789 stringstream ss[2]; 790// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 791 ss[0] << pStruct->depth; 792// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 793 ss[1] << pStruct->stencil; 794// CODEGEN : file ../vk_helper.py line #1113 795 final_str = prefix + "depth = " + ss[0].str() + "\n" + prefix + "stencil = " + ss[1].str() + "\n"; 796 return final_str; 797} 798// CODEGEN : file ../vk_helper.py line #906 799std::string vk_print_vkclearrect(const VkClearRect* pStruct, const std::string prefix) 800{ 801// CODEGEN : file ../vk_helper.py line #912 802 using namespace StreamControl; 803 using namespace std; 804 string final_str; 805 string tmp_str; 806 string extra_indent = " " + prefix; 807 stringstream ss[3]; 808 string stp_strs[1]; 809// CODEGEN : file ../vk_helper.py line #1037 810 tmp_str = vk_print_vkrect2d(&pStruct->rect, extra_indent); 811 ss[0] << "0x" << &pStruct->rect; 812 stp_strs[0] = " " + prefix + "rect (addr)\n" + tmp_str; 813// CODEGEN : file ../vk_helper.py line #1042 814 ss[0].str(""); 815// CODEGEN : file ../vk_helper.py line #1054 816 ss[0].str("addr"); 817// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 818 ss[1] << pStruct->baseArrayLayer; 819// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 820 ss[2] << pStruct->layerCount; 821// CODEGEN : file ../vk_helper.py line #1113 822 final_str = prefix + "rect = " + ss[0].str() + "\n" + prefix + "baseArrayLayer = " + ss[1].str() + "\n" + prefix + "layerCount = " + ss[2].str() + "\n" + stp_strs[0]; 823 return final_str; 824} 825// CODEGEN : file ../vk_helper.py line #906 826std::string vk_print_vkclearvalue(const VkClearValue* pStruct, const std::string prefix) 827{ 828// CODEGEN : file ../vk_helper.py line #912 829 using namespace StreamControl; 830 using namespace std; 831 string final_str; 832 string tmp_str; 833 string extra_indent = " " + prefix; 834 stringstream ss[2]; 835 string stp_strs[2]; 836// CODEGEN : file ../vk_helper.py line #1037 837 tmp_str = vk_print_vkclearcolorvalue(&pStruct->color, extra_indent); 838 ss[0] << "0x" << &pStruct->color; 839 stp_strs[0] = " " + prefix + "color (addr)\n" + tmp_str; 840// CODEGEN : file ../vk_helper.py line #1042 841 ss[0].str(""); 842// CODEGEN : file ../vk_helper.py line #1037 843 tmp_str = vk_print_vkcleardepthstencilvalue(&pStruct->depthStencil, extra_indent); 844 ss[1] << "0x" << &pStruct->depthStencil; 845 stp_strs[1] = " " + prefix + "depthStencil (addr)\n" + tmp_str; 846// CODEGEN : file ../vk_helper.py line #1042 847 ss[1].str(""); 848// CODEGEN : file ../vk_helper.py line #1054 849 ss[0].str("addr"); 850// CODEGEN : file ../vk_helper.py line #1054 851 ss[1].str("addr"); 852// CODEGEN : file ../vk_helper.py line #1113 853 final_str = prefix + "color = " + ss[0].str() + "\n" + prefix + "depthStencil = " + ss[1].str() + "\n" + stp_strs[1] + stp_strs[0]; 854 return final_str; 855} 856// CODEGEN : file ../vk_helper.py line #906 857std::string vk_print_vkcommandbufferallocateinfo(const VkCommandBufferAllocateInfo* pStruct, const std::string prefix) 858{ 859// CODEGEN : file ../vk_helper.py line #912 860 using namespace StreamControl; 861 using namespace std; 862 string final_str; 863 string tmp_str; 864 string extra_indent = " " + prefix; 865 stringstream ss[3]; 866 string stp_strs[1]; 867// CODEGEN : file ../vk_helper.py line #1011 868 if (pStruct->pNext) { 869// CODEGEN : file ../vk_helper.py line #1015 870 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 871 ss[0] << "0x" << &pStruct->pNext; 872// CODEGEN : file ../vk_helper.py line #1027 873 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 874 ss[0].str(""); 875 } 876 else 877 stp_strs[0] = ""; 878// CODEGEN : file ../vk_helper.py line #1069 879 if (StreamControl::writeAddress) 880 ss[0] << "0x" << pStruct->pNext; 881 else 882 ss[0].str("address"); 883// CODEGEN : file ../vk_helper.py line #1085 884 ss[1] << "0x" << pStruct->commandPool; 885// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 886 ss[2] << "0x" << pStruct->commandBufferCount; 887// CODEGEN : file ../vk_helper.py line #1113 888 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "commandPool = " + ss[1].str() + "\n" + prefix + "level = " + string_VkCommandBufferLevel(pStruct->level) + "\n" + prefix + "commandBufferCount = " + ss[2].str() + "\n" + stp_strs[0]; 889 return final_str; 890} 891// CODEGEN : file ../vk_helper.py line #906 892std::string vk_print_vkcommandbufferbegininfo(const VkCommandBufferBeginInfo* pStruct, const std::string prefix) 893{ 894// CODEGEN : file ../vk_helper.py line #912 895 using namespace StreamControl; 896 using namespace std; 897 string final_str; 898 string tmp_str; 899 string extra_indent = " " + prefix; 900 stringstream ss[3]; 901 string stp_strs[2]; 902// CODEGEN : file ../vk_helper.py line #1011 903 if (pStruct->pNext) { 904// CODEGEN : file ../vk_helper.py line #1015 905 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 906 ss[0] << "0x" << &pStruct->pNext; 907// CODEGEN : file ../vk_helper.py line #1027 908 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 909 ss[0].str(""); 910 } 911 else 912 stp_strs[0] = ""; 913// CODEGEN : file ../vk_helper.py line #1011 914 if (pStruct->pInheritanceInfo) { 915// CODEGEN : file ../vk_helper.py line #1023 916 tmp_str = vk_print_vkcommandbufferinheritanceinfo(pStruct->pInheritanceInfo, extra_indent); 917 ss[1] << "0x" << &pStruct->pInheritanceInfo; 918// CODEGEN : file ../vk_helper.py line #1027 919 stp_strs[1] = " " + prefix + "pInheritanceInfo (addr)\n" + tmp_str; 920 ss[1].str(""); 921 } 922 else 923 stp_strs[1] = ""; 924// CODEGEN : file ../vk_helper.py line #1069 925 if (StreamControl::writeAddress) 926 ss[0] << "0x" << pStruct->pNext; 927 else 928 ss[0].str("address"); 929// CODEGEN : file ../vk_helper.py line #1085 930 ss[1] << "0x" << pStruct->flags; 931// CODEGEN : file ../vk_helper.py line #1085 932 ss[2] << "0x" << pStruct->pInheritanceInfo; 933// CODEGEN : file ../vk_helper.py line #1113 934 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "pInheritanceInfo = " + ss[2].str() + "\n" + stp_strs[1] + stp_strs[0]; 935 return final_str; 936} 937// CODEGEN : file ../vk_helper.py line #906 938std::string vk_print_vkcommandbufferinheritanceinfo(const VkCommandBufferInheritanceInfo* pStruct, const std::string prefix) 939{ 940// CODEGEN : file ../vk_helper.py line #912 941 using namespace StreamControl; 942 using namespace std; 943 string final_str; 944 string tmp_str; 945 string extra_indent = " " + prefix; 946 stringstream ss[7]; 947 string stp_strs[1]; 948// CODEGEN : file ../vk_helper.py line #1011 949 if (pStruct->pNext) { 950// CODEGEN : file ../vk_helper.py line #1015 951 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 952 ss[0] << "0x" << &pStruct->pNext; 953// CODEGEN : file ../vk_helper.py line #1027 954 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 955 ss[0].str(""); 956 } 957 else 958 stp_strs[0] = ""; 959// CODEGEN : file ../vk_helper.py line #1069 960 if (StreamControl::writeAddress) 961 ss[0] << "0x" << pStruct->pNext; 962 else 963 ss[0].str("address"); 964// CODEGEN : file ../vk_helper.py line #1085 965 ss[1] << "0x" << pStruct->renderPass; 966// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 967 ss[2] << pStruct->subpass; 968// CODEGEN : file ../vk_helper.py line #1085 969 ss[3] << "0x" << pStruct->framebuffer; 970// CODEGEN : file ../vk_helper.py line #1063 971 ss[4].str(pStruct->occlusionQueryEnable ? "TRUE" : "FALSE"); 972// CODEGEN : file ../vk_helper.py line #1085 973 ss[5] << "0x" << pStruct->queryFlags; 974// CODEGEN : file ../vk_helper.py line #1085 975 ss[6] << "0x" << pStruct->pipelineStatistics; 976// CODEGEN : file ../vk_helper.py line #1113 977 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "renderPass = " + ss[1].str() + "\n" + prefix + "subpass = " + ss[2].str() + "\n" + prefix + "framebuffer = " + ss[3].str() + "\n" + prefix + "occlusionQueryEnable = " + ss[4].str() + "\n" + prefix + "queryFlags = " + ss[5].str() + "\n" + prefix + "pipelineStatistics = " + ss[6].str() + "\n" + stp_strs[0]; 978 return final_str; 979} 980// CODEGEN : file ../vk_helper.py line #906 981std::string vk_print_vkcommandpoolcreateinfo(const VkCommandPoolCreateInfo* pStruct, const std::string prefix) 982{ 983// CODEGEN : file ../vk_helper.py line #912 984 using namespace StreamControl; 985 using namespace std; 986 string final_str; 987 string tmp_str; 988 string extra_indent = " " + prefix; 989 stringstream ss[3]; 990 string stp_strs[1]; 991// CODEGEN : file ../vk_helper.py line #1011 992 if (pStruct->pNext) { 993// CODEGEN : file ../vk_helper.py line #1015 994 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 995 ss[0] << "0x" << &pStruct->pNext; 996// CODEGEN : file ../vk_helper.py line #1027 997 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 998 ss[0].str(""); 999 } 1000 else 1001 stp_strs[0] = ""; 1002// CODEGEN : file ../vk_helper.py line #1069 1003 if (StreamControl::writeAddress) 1004 ss[0] << "0x" << pStruct->pNext; 1005 else 1006 ss[0].str("address"); 1007// CODEGEN : file ../vk_helper.py line #1085 1008 ss[1] << "0x" << pStruct->flags; 1009// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1010 ss[2] << pStruct->queueFamilyIndex; 1011// CODEGEN : file ../vk_helper.py line #1113 1012 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "queueFamilyIndex = " + ss[2].str() + "\n" + stp_strs[0]; 1013 return final_str; 1014} 1015// CODEGEN : file ../vk_helper.py line #906 1016std::string vk_print_vkcomponentmapping(const VkComponentMapping* pStruct, const std::string prefix) 1017{ 1018// CODEGEN : file ../vk_helper.py line #912 1019 using namespace StreamControl; 1020 using namespace std; 1021 string final_str; 1022 string tmp_str; 1023 string extra_indent = " " + prefix; 1024// CODEGEN : file ../vk_helper.py line #1113 1025 final_str = prefix + "r = " + string_VkComponentSwizzle(pStruct->r) + "\n" + prefix + "g = " + string_VkComponentSwizzle(pStruct->g) + "\n" + prefix + "b = " + string_VkComponentSwizzle(pStruct->b) + "\n" + prefix + "a = " + string_VkComponentSwizzle(pStruct->a) + "\n"; 1026 return final_str; 1027} 1028// CODEGEN : file ../vk_helper.py line #906 1029std::string vk_print_vkcomputepipelinecreateinfo(const VkComputePipelineCreateInfo* pStruct, const std::string prefix) 1030{ 1031// CODEGEN : file ../vk_helper.py line #912 1032 using namespace StreamControl; 1033 using namespace std; 1034 string final_str; 1035 string tmp_str; 1036 string extra_indent = " " + prefix; 1037 stringstream ss[6]; 1038 string stp_strs[2]; 1039// CODEGEN : file ../vk_helper.py line #1011 1040 if (pStruct->pNext) { 1041// CODEGEN : file ../vk_helper.py line #1015 1042 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1043 ss[0] << "0x" << &pStruct->pNext; 1044// CODEGEN : file ../vk_helper.py line #1027 1045 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1046 ss[0].str(""); 1047 } 1048 else 1049 stp_strs[0] = ""; 1050// CODEGEN : file ../vk_helper.py line #1037 1051 tmp_str = vk_print_vkpipelineshaderstagecreateinfo(&pStruct->stage, extra_indent); 1052 ss[1] << "0x" << &pStruct->stage; 1053 stp_strs[1] = " " + prefix + "stage (addr)\n" + tmp_str; 1054// CODEGEN : file ../vk_helper.py line #1042 1055 ss[1].str(""); 1056// CODEGEN : file ../vk_helper.py line #1069 1057 if (StreamControl::writeAddress) 1058 ss[0] << "0x" << pStruct->pNext; 1059 else 1060 ss[0].str("address"); 1061// CODEGEN : file ../vk_helper.py line #1085 1062 ss[1] << "0x" << pStruct->flags; 1063// CODEGEN : file ../vk_helper.py line #1054 1064 ss[2].str("addr"); 1065// CODEGEN : file ../vk_helper.py line #1085 1066 ss[3] << "0x" << pStruct->layout; 1067// CODEGEN : file ../vk_helper.py line #1085 1068 ss[4] << "0x" << pStruct->basePipelineHandle; 1069// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1070 ss[5] << pStruct->basePipelineIndex; 1071// CODEGEN : file ../vk_helper.py line #1113 1072 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "stage = " + ss[2].str() + "\n" + prefix + "layout = " + ss[3].str() + "\n" + prefix + "basePipelineHandle = " + ss[4].str() + "\n" + prefix + "basePipelineIndex = " + ss[5].str() + "\n" + stp_strs[1] + stp_strs[0]; 1073 return final_str; 1074} 1075// CODEGEN : file ../vk_helper.py line #906 1076std::string vk_print_vkcopydescriptorset(const VkCopyDescriptorSet* pStruct, const std::string prefix) 1077{ 1078// CODEGEN : file ../vk_helper.py line #912 1079 using namespace StreamControl; 1080 using namespace std; 1081 string final_str; 1082 string tmp_str; 1083 string extra_indent = " " + prefix; 1084 stringstream ss[8]; 1085 string stp_strs[1]; 1086// CODEGEN : file ../vk_helper.py line #1011 1087 if (pStruct->pNext) { 1088// CODEGEN : file ../vk_helper.py line #1015 1089 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1090 ss[0] << "0x" << &pStruct->pNext; 1091// CODEGEN : file ../vk_helper.py line #1027 1092 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1093 ss[0].str(""); 1094 } 1095 else 1096 stp_strs[0] = ""; 1097// CODEGEN : file ../vk_helper.py line #1069 1098 if (StreamControl::writeAddress) 1099 ss[0] << "0x" << pStruct->pNext; 1100 else 1101 ss[0].str("address"); 1102// CODEGEN : file ../vk_helper.py line #1085 1103 ss[1] << "0x" << pStruct->srcSet; 1104// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1105 ss[2] << pStruct->srcBinding; 1106// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1107 ss[3] << pStruct->srcArrayElement; 1108// CODEGEN : file ../vk_helper.py line #1085 1109 ss[4] << "0x" << pStruct->dstSet; 1110// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1111 ss[5] << pStruct->dstBinding; 1112// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1113 ss[6] << pStruct->dstArrayElement; 1114// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1115 ss[7] << pStruct->descriptorCount; 1116// CODEGEN : file ../vk_helper.py line #1113 1117 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "srcSet = " + ss[1].str() + "\n" + prefix + "srcBinding = " + ss[2].str() + "\n" + prefix + "srcArrayElement = " + ss[3].str() + "\n" + prefix + "dstSet = " + ss[4].str() + "\n" + prefix + "dstBinding = " + ss[5].str() + "\n" + prefix + "dstArrayElement = " + ss[6].str() + "\n" + prefix + "descriptorCount = " + ss[7].str() + "\n" + stp_strs[0]; 1118 return final_str; 1119} 1120// CODEGEN : file ../vk_helper.py line #906 1121std::string vk_print_vkdebugmarkermarkerinfoext(const VkDebugMarkerMarkerInfoEXT* pStruct, const std::string prefix) 1122{ 1123// CODEGEN : file ../vk_helper.py line #912 1124 using namespace StreamControl; 1125 using namespace std; 1126 string final_str; 1127 string tmp_str; 1128 string extra_indent = " " + prefix; 1129 stringstream ss[3]; 1130 string stp_strs[2]; 1131// CODEGEN : file ../vk_helper.py line #1011 1132 if (pStruct->pNext) { 1133// CODEGEN : file ../vk_helper.py line #1015 1134 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1135 ss[0] << "0x" << &pStruct->pNext; 1136// CODEGEN : file ../vk_helper.py line #1027 1137 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1138 ss[0].str(""); 1139 } 1140 else 1141 stp_strs[0] = ""; 1142// CODEGEN : file ../vk_helper.py line #931 1143// CODEGEN : file ../vk_helper.py line #936 1144// CODEGEN : file ../vk_helper.py line #938 1145 stp_strs[1] = ""; 1146 stringstream index_ss; 1147 for (uint32_t i = 0; i < 4; i++) { 1148 index_ss.str(""); 1149 index_ss << i; 1150// CODEGEN : file ../vk_helper.py line #989 1151 ss[1] << pStruct->color[i]; 1152 stp_strs[1] += " " + prefix + "color[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 1153// CODEGEN : file ../vk_helper.py line #999 1154 ss[1].str(""); 1155 } 1156// CODEGEN : file ../vk_helper.py line #1069 1157 if (StreamControl::writeAddress) 1158 ss[0] << "0x" << pStruct->pNext; 1159 else 1160 ss[0].str("address"); 1161// CODEGEN : file ../vk_helper.py line #1075 1162 if (pStruct->pMarkerName != NULL) { 1163 ss[1] << pStruct->pMarkerName; 1164 } else { 1165 ss[1] << ""; 1166 } 1167// CODEGEN : file ../vk_helper.py line #1060 1168 ss[2] << "0x" << (void*)pStruct->color; 1169// CODEGEN : file ../vk_helper.py line #1113 1170 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "pMarkerName = " + ss[1].str() + "\n" + prefix + "color = " + ss[2].str() + "\n" + stp_strs[1] + stp_strs[0]; 1171 return final_str; 1172} 1173// CODEGEN : file ../vk_helper.py line #906 1174std::string vk_print_vkdebugmarkerobjectnameinfoext(const VkDebugMarkerObjectNameInfoEXT* pStruct, const std::string prefix) 1175{ 1176// CODEGEN : file ../vk_helper.py line #912 1177 using namespace StreamControl; 1178 using namespace std; 1179 string final_str; 1180 string tmp_str; 1181 string extra_indent = " " + prefix; 1182 stringstream ss[3]; 1183 string stp_strs[1]; 1184// CODEGEN : file ../vk_helper.py line #1011 1185 if (pStruct->pNext) { 1186// CODEGEN : file ../vk_helper.py line #1015 1187 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1188 ss[0] << "0x" << &pStruct->pNext; 1189// CODEGEN : file ../vk_helper.py line #1027 1190 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1191 ss[0].str(""); 1192 } 1193 else 1194 stp_strs[0] = ""; 1195// CODEGEN : file ../vk_helper.py line #1069 1196 if (StreamControl::writeAddress) 1197 ss[0] << "0x" << pStruct->pNext; 1198 else 1199 ss[0].str("address"); 1200// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 1201 ss[1] << "0x" << pStruct->object; 1202// CODEGEN : file ../vk_helper.py line #1075 1203 if (pStruct->pObjectName != NULL) { 1204 ss[2] << pStruct->pObjectName; 1205 } else { 1206 ss[2] << ""; 1207 } 1208// CODEGEN : file ../vk_helper.py line #1113 1209 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "objectType = " + string_VkDebugReportObjectTypeEXT(pStruct->objectType) + "\n" + prefix + "object = " + ss[1].str() + "\n" + prefix + "pObjectName = " + ss[2].str() + "\n" + stp_strs[0]; 1210 return final_str; 1211} 1212// CODEGEN : file ../vk_helper.py line #906 1213std::string vk_print_vkdebugmarkerobjecttaginfoext(const VkDebugMarkerObjectTagInfoEXT* pStruct, const std::string prefix) 1214{ 1215// CODEGEN : file ../vk_helper.py line #912 1216 using namespace StreamControl; 1217 using namespace std; 1218 string final_str; 1219 string tmp_str; 1220 string extra_indent = " " + prefix; 1221 stringstream ss[5]; 1222 string stp_strs[1]; 1223// CODEGEN : file ../vk_helper.py line #1011 1224 if (pStruct->pNext) { 1225// CODEGEN : file ../vk_helper.py line #1015 1226 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1227 ss[0] << "0x" << &pStruct->pNext; 1228// CODEGEN : file ../vk_helper.py line #1027 1229 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1230 ss[0].str(""); 1231 } 1232 else 1233 stp_strs[0] = ""; 1234// CODEGEN : file ../vk_helper.py line #1069 1235 if (StreamControl::writeAddress) 1236 ss[0] << "0x" << pStruct->pNext; 1237 else 1238 ss[0].str("address"); 1239// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 1240 ss[1] << "0x" << pStruct->object; 1241// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1242 ss[2] << pStruct->tagName; 1243// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1244 ss[3] << pStruct->tagSize; 1245// CODEGEN : file ../vk_helper.py line #1069 1246 if (StreamControl::writeAddress) 1247 ss[4] << "0x" << pStruct->pTag; 1248 else 1249 ss[4].str("address"); 1250// CODEGEN : file ../vk_helper.py line #1113 1251 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "objectType = " + string_VkDebugReportObjectTypeEXT(pStruct->objectType) + "\n" + prefix + "object = " + ss[1].str() + "\n" + prefix + "tagName = " + ss[2].str() + "\n" + prefix + "tagSize = " + ss[3].str() + "\n" + prefix + "pTag = " + ss[4].str() + "\n" + stp_strs[0]; 1252 return final_str; 1253} 1254// CODEGEN : file ../vk_helper.py line #906 1255std::string vk_print_vkdebugreportcallbackcreateinfoext(const VkDebugReportCallbackCreateInfoEXT* pStruct, const std::string prefix) 1256{ 1257// CODEGEN : file ../vk_helper.py line #912 1258 using namespace StreamControl; 1259 using namespace std; 1260 string final_str; 1261 string tmp_str; 1262 string extra_indent = " " + prefix; 1263 stringstream ss[4]; 1264 string stp_strs[1]; 1265// CODEGEN : file ../vk_helper.py line #1011 1266 if (pStruct->pNext) { 1267// CODEGEN : file ../vk_helper.py line #1015 1268 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1269 ss[0] << "0x" << &pStruct->pNext; 1270// CODEGEN : file ../vk_helper.py line #1027 1271 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1272 ss[0].str(""); 1273 } 1274 else 1275 stp_strs[0] = ""; 1276// CODEGEN : file ../vk_helper.py line #1069 1277 if (StreamControl::writeAddress) 1278 ss[0] << "0x" << pStruct->pNext; 1279 else 1280 ss[0].str("address"); 1281// CODEGEN : file ../vk_helper.py line #1085 1282 ss[1] << "0x" << pStruct->flags; 1283// CODEGEN : file ../vk_helper.py line #1085 1284 ss[2] << "0x" << pStruct->pfnCallback; 1285// CODEGEN : file ../vk_helper.py line #1069 1286 if (StreamControl::writeAddress) 1287 ss[3] << "0x" << pStruct->pUserData; 1288 else 1289 ss[3].str("address"); 1290// CODEGEN : file ../vk_helper.py line #1113 1291 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "pfnCallback = " + ss[2].str() + "\n" + prefix + "pUserData = " + ss[3].str() + "\n" + stp_strs[0]; 1292 return final_str; 1293} 1294// CODEGEN : file ../vk_helper.py line #906 1295std::string vk_print_vkdescriptorbufferinfo(const VkDescriptorBufferInfo* pStruct, const std::string prefix) 1296{ 1297// CODEGEN : file ../vk_helper.py line #912 1298 using namespace StreamControl; 1299 using namespace std; 1300 string final_str; 1301 string tmp_str; 1302 string extra_indent = " " + prefix; 1303 stringstream ss[3]; 1304// CODEGEN : file ../vk_helper.py line #1085 1305 ss[0] << "0x" << pStruct->buffer; 1306// CODEGEN : file ../vk_helper.py line #1085 1307 ss[1] << "0x" << pStruct->offset; 1308// CODEGEN : file ../vk_helper.py line #1085 1309 ss[2] << "0x" << pStruct->range; 1310// CODEGEN : file ../vk_helper.py line #1113 1311 final_str = prefix + "buffer = " + ss[0].str() + "\n" + prefix + "offset = " + ss[1].str() + "\n" + prefix + "range = " + ss[2].str() + "\n"; 1312 return final_str; 1313} 1314// CODEGEN : file ../vk_helper.py line #906 1315std::string vk_print_vkdescriptorimageinfo(const VkDescriptorImageInfo* pStruct, const std::string prefix) 1316{ 1317// CODEGEN : file ../vk_helper.py line #912 1318 using namespace StreamControl; 1319 using namespace std; 1320 string final_str; 1321 string tmp_str; 1322 string extra_indent = " " + prefix; 1323 stringstream ss[2]; 1324// CODEGEN : file ../vk_helper.py line #1085 1325 ss[0] << "0x" << pStruct->sampler; 1326// CODEGEN : file ../vk_helper.py line #1085 1327 ss[1] << "0x" << pStruct->imageView; 1328// CODEGEN : file ../vk_helper.py line #1113 1329 final_str = prefix + "sampler = " + ss[0].str() + "\n" + prefix + "imageView = " + ss[1].str() + "\n" + prefix + "imageLayout = " + string_VkImageLayout(pStruct->imageLayout) + "\n"; 1330 return final_str; 1331} 1332// CODEGEN : file ../vk_helper.py line #906 1333std::string vk_print_vkdescriptorpoolcreateinfo(const VkDescriptorPoolCreateInfo* pStruct, const std::string prefix) 1334{ 1335// CODEGEN : file ../vk_helper.py line #912 1336 using namespace StreamControl; 1337 using namespace std; 1338 string final_str; 1339 string tmp_str; 1340 string extra_indent = " " + prefix; 1341 stringstream ss[5]; 1342 string stp_strs[2]; 1343// CODEGEN : file ../vk_helper.py line #1011 1344 if (pStruct->pNext) { 1345// CODEGEN : file ../vk_helper.py line #1015 1346 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1347 ss[0] << "0x" << &pStruct->pNext; 1348// CODEGEN : file ../vk_helper.py line #1027 1349 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1350 ss[0].str(""); 1351 } 1352 else 1353 stp_strs[0] = ""; 1354// CODEGEN : file ../vk_helper.py line #931 1355// CODEGEN : file ../vk_helper.py line #933 1356// CODEGEN : file ../vk_helper.py line #938 1357 stp_strs[1] = ""; 1358 stringstream index_ss; 1359 if (pStruct->pPoolSizes) { 1360 for (uint32_t i = 0; i < pStruct->poolSizeCount; i++) { 1361 index_ss.str(""); 1362 index_ss << i; 1363// CODEGEN : file ../vk_helper.py line #979 1364 ss[1] << "0x" << &pStruct->pPoolSizes[i]; 1365 tmp_str = vk_print_vkdescriptorpoolsize(&pStruct->pPoolSizes[i], extra_indent); 1366// CODEGEN : file ../vk_helper.py line #983 1367 stp_strs[1] += " " + prefix + "pPoolSizes[" + index_ss.str() + "] (addr)\n" + tmp_str; 1368// CODEGEN : file ../vk_helper.py line #999 1369 ss[1].str(""); 1370 } 1371 } 1372// CODEGEN : file ../vk_helper.py line #1069 1373 if (StreamControl::writeAddress) 1374 ss[0] << "0x" << pStruct->pNext; 1375 else 1376 ss[0].str("address"); 1377// CODEGEN : file ../vk_helper.py line #1085 1378 ss[1] << "0x" << pStruct->flags; 1379// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1380 ss[2] << pStruct->maxSets; 1381// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1382 ss[3] << pStruct->poolSizeCount; 1383// CODEGEN : file ../vk_helper.py line #1060 1384 ss[4] << "0x" << (void*)pStruct->pPoolSizes; 1385// CODEGEN : file ../vk_helper.py line #1113 1386 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "maxSets = " + ss[2].str() + "\n" + prefix + "poolSizeCount = " + ss[3].str() + "\n" + prefix + "pPoolSizes = " + ss[4].str() + "\n" + stp_strs[1] + stp_strs[0]; 1387 return final_str; 1388} 1389// CODEGEN : file ../vk_helper.py line #906 1390std::string vk_print_vkdescriptorpoolsize(const VkDescriptorPoolSize* pStruct, const std::string prefix) 1391{ 1392// CODEGEN : file ../vk_helper.py line #912 1393 using namespace StreamControl; 1394 using namespace std; 1395 string final_str; 1396 string tmp_str; 1397 string extra_indent = " " + prefix; 1398 stringstream ss[1]; 1399// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1400 ss[0] << pStruct->descriptorCount; 1401// CODEGEN : file ../vk_helper.py line #1113 1402 final_str = prefix + "type = " + string_VkDescriptorType(pStruct->type) + "\n" + prefix + "descriptorCount = " + ss[0].str() + "\n"; 1403 return final_str; 1404} 1405// CODEGEN : file ../vk_helper.py line #906 1406std::string vk_print_vkdescriptorsetallocateinfo(const VkDescriptorSetAllocateInfo* pStruct, const std::string prefix) 1407{ 1408// CODEGEN : file ../vk_helper.py line #912 1409 using namespace StreamControl; 1410 using namespace std; 1411 string final_str; 1412 string tmp_str; 1413 string extra_indent = " " + prefix; 1414 stringstream ss[4]; 1415 string stp_strs[2]; 1416// CODEGEN : file ../vk_helper.py line #1011 1417 if (pStruct->pNext) { 1418// CODEGEN : file ../vk_helper.py line #1015 1419 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1420 ss[0] << "0x" << &pStruct->pNext; 1421// CODEGEN : file ../vk_helper.py line #1027 1422 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1423 ss[0].str(""); 1424 } 1425 else 1426 stp_strs[0] = ""; 1427// CODEGEN : file ../vk_helper.py line #931 1428// CODEGEN : file ../vk_helper.py line #933 1429// CODEGEN : file ../vk_helper.py line #938 1430 stp_strs[1] = ""; 1431 stringstream index_ss; 1432 if (pStruct->pSetLayouts) { 1433 for (uint32_t i = 0; i < pStruct->descriptorSetCount; i++) { 1434 index_ss.str(""); 1435 index_ss << i; 1436// CODEGEN : file ../vk_helper.py line #989 1437 ss[1] << "0x" << pStruct->pSetLayouts[i]; 1438 stp_strs[1] += " " + prefix + "pSetLayouts[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 1439// CODEGEN : file ../vk_helper.py line #999 1440 ss[1].str(""); 1441 } 1442 } 1443// CODEGEN : file ../vk_helper.py line #1069 1444 if (StreamControl::writeAddress) 1445 ss[0] << "0x" << pStruct->pNext; 1446 else 1447 ss[0].str("address"); 1448// CODEGEN : file ../vk_helper.py line #1085 1449 ss[1] << "0x" << pStruct->descriptorPool; 1450// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1451 ss[2] << pStruct->descriptorSetCount; 1452// CODEGEN : file ../vk_helper.py line #1060 1453 ss[3] << "0x" << (void*)pStruct->pSetLayouts; 1454// CODEGEN : file ../vk_helper.py line #1113 1455 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "descriptorPool = " + ss[1].str() + "\n" + prefix + "descriptorSetCount = " + ss[2].str() + "\n" + prefix + "pSetLayouts = " + ss[3].str() + "\n" + stp_strs[1] + stp_strs[0]; 1456 return final_str; 1457} 1458// CODEGEN : file ../vk_helper.py line #906 1459std::string vk_print_vkdescriptorsetlayoutbinding(const VkDescriptorSetLayoutBinding* pStruct, const std::string prefix) 1460{ 1461// CODEGEN : file ../vk_helper.py line #912 1462 using namespace StreamControl; 1463 using namespace std; 1464 string final_str; 1465 string tmp_str; 1466 string extra_indent = " " + prefix; 1467 stringstream ss[4]; 1468 string stp_strs[1]; 1469// CODEGEN : file ../vk_helper.py line #931 1470// CODEGEN : file ../vk_helper.py line #933 1471// CODEGEN : file ../vk_helper.py line #938 1472 stp_strs[0] = ""; 1473 stringstream index_ss; 1474 if (pStruct->pImmutableSamplers) { 1475 for (uint32_t i = 0; i < pStruct->descriptorCount; i++) { 1476 index_ss.str(""); 1477 index_ss << i; 1478// CODEGEN : file ../vk_helper.py line #989 1479 ss[0] << "0x" << pStruct->pImmutableSamplers[i]; 1480 stp_strs[0] += " " + prefix + "pImmutableSamplers[" + index_ss.str() + "].handle = " + ss[0].str() + "\n"; 1481// CODEGEN : file ../vk_helper.py line #999 1482 ss[0].str(""); 1483 } 1484 } 1485// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1486 ss[0] << pStruct->binding; 1487// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1488 ss[1] << pStruct->descriptorCount; 1489// CODEGEN : file ../vk_helper.py line #1085 1490 ss[2] << "0x" << pStruct->stageFlags; 1491// CODEGEN : file ../vk_helper.py line #1060 1492 ss[3] << "0x" << (void*)pStruct->pImmutableSamplers; 1493// CODEGEN : file ../vk_helper.py line #1113 1494 final_str = prefix + "binding = " + ss[0].str() + "\n" + prefix + "descriptorType = " + string_VkDescriptorType(pStruct->descriptorType) + "\n" + prefix + "descriptorCount = " + ss[1].str() + "\n" + prefix + "stageFlags = " + ss[2].str() + "\n" + prefix + "pImmutableSamplers = " + ss[3].str() + "\n" + stp_strs[0]; 1495 return final_str; 1496} 1497// CODEGEN : file ../vk_helper.py line #906 1498std::string vk_print_vkdescriptorsetlayoutcreateinfo(const VkDescriptorSetLayoutCreateInfo* pStruct, const std::string prefix) 1499{ 1500// CODEGEN : file ../vk_helper.py line #912 1501 using namespace StreamControl; 1502 using namespace std; 1503 string final_str; 1504 string tmp_str; 1505 string extra_indent = " " + prefix; 1506 stringstream ss[4]; 1507 string stp_strs[2]; 1508// CODEGEN : file ../vk_helper.py line #1011 1509 if (pStruct->pNext) { 1510// CODEGEN : file ../vk_helper.py line #1015 1511 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1512 ss[0] << "0x" << &pStruct->pNext; 1513// CODEGEN : file ../vk_helper.py line #1027 1514 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1515 ss[0].str(""); 1516 } 1517 else 1518 stp_strs[0] = ""; 1519// CODEGEN : file ../vk_helper.py line #931 1520// CODEGEN : file ../vk_helper.py line #933 1521// CODEGEN : file ../vk_helper.py line #938 1522 stp_strs[1] = ""; 1523 stringstream index_ss; 1524 if (pStruct->pBindings) { 1525 for (uint32_t i = 0; i < pStruct->bindingCount; i++) { 1526 index_ss.str(""); 1527 index_ss << i; 1528// CODEGEN : file ../vk_helper.py line #979 1529 ss[1] << "0x" << &pStruct->pBindings[i]; 1530 tmp_str = vk_print_vkdescriptorsetlayoutbinding(&pStruct->pBindings[i], extra_indent); 1531// CODEGEN : file ../vk_helper.py line #983 1532 stp_strs[1] += " " + prefix + "pBindings[" + index_ss.str() + "] (addr)\n" + tmp_str; 1533// CODEGEN : file ../vk_helper.py line #999 1534 ss[1].str(""); 1535 } 1536 } 1537// CODEGEN : file ../vk_helper.py line #1069 1538 if (StreamControl::writeAddress) 1539 ss[0] << "0x" << pStruct->pNext; 1540 else 1541 ss[0].str("address"); 1542// CODEGEN : file ../vk_helper.py line #1085 1543 ss[1] << "0x" << pStruct->flags; 1544// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1545 ss[2] << pStruct->bindingCount; 1546// CODEGEN : file ../vk_helper.py line #1060 1547 ss[3] << "0x" << (void*)pStruct->pBindings; 1548// CODEGEN : file ../vk_helper.py line #1113 1549 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "bindingCount = " + ss[2].str() + "\n" + prefix + "pBindings = " + ss[3].str() + "\n" + stp_strs[1] + stp_strs[0]; 1550 return final_str; 1551} 1552// CODEGEN : file ../vk_helper.py line #906 1553std::string vk_print_vkdevicecreateinfo(const VkDeviceCreateInfo* pStruct, const std::string prefix) 1554{ 1555// CODEGEN : file ../vk_helper.py line #912 1556 using namespace StreamControl; 1557 using namespace std; 1558 string final_str; 1559 string tmp_str; 1560 string extra_indent = " " + prefix; 1561 stringstream ss[9]; 1562 string stp_strs[5]; 1563// CODEGEN : file ../vk_helper.py line #1011 1564 if (pStruct->pNext) { 1565// CODEGEN : file ../vk_helper.py line #1015 1566 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1567 ss[0] << "0x" << &pStruct->pNext; 1568// CODEGEN : file ../vk_helper.py line #1027 1569 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1570 ss[0].str(""); 1571 } 1572 else 1573 stp_strs[0] = ""; 1574// CODEGEN : file ../vk_helper.py line #931 1575// CODEGEN : file ../vk_helper.py line #933 1576// CODEGEN : file ../vk_helper.py line #938 1577 stp_strs[1] = ""; 1578 stringstream index_ss; 1579 if (pStruct->pQueueCreateInfos) { 1580 for (uint32_t i = 0; i < pStruct->queueCreateInfoCount; i++) { 1581 index_ss.str(""); 1582 index_ss << i; 1583// CODEGEN : file ../vk_helper.py line #979 1584 ss[1] << "0x" << &pStruct->pQueueCreateInfos[i]; 1585 tmp_str = vk_print_vkdevicequeuecreateinfo(&pStruct->pQueueCreateInfos[i], extra_indent); 1586// CODEGEN : file ../vk_helper.py line #983 1587 stp_strs[1] += " " + prefix + "pQueueCreateInfos[" + index_ss.str() + "] (addr)\n" + tmp_str; 1588// CODEGEN : file ../vk_helper.py line #999 1589 ss[1].str(""); 1590 } 1591 } 1592// CODEGEN : file ../vk_helper.py line #931 1593// CODEGEN : file ../vk_helper.py line #933 1594// CODEGEN : file ../vk_helper.py line #938 1595 stp_strs[2] = ""; 1596 if (pStruct->ppEnabledLayerNames) { 1597 for (uint32_t i = 0; i < pStruct->enabledLayerCount; i++) { 1598 index_ss.str(""); 1599 index_ss << i; 1600// CODEGEN : file ../vk_helper.py line #989 1601 ss[2] << "0x" << pStruct->ppEnabledLayerNames[i]; 1602 stp_strs[2] += " " + prefix + "ppEnabledLayerNames[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 1603// CODEGEN : file ../vk_helper.py line #999 1604 ss[2].str(""); 1605 } 1606 } 1607// CODEGEN : file ../vk_helper.py line #931 1608// CODEGEN : file ../vk_helper.py line #933 1609// CODEGEN : file ../vk_helper.py line #938 1610 stp_strs[3] = ""; 1611 if (pStruct->ppEnabledExtensionNames) { 1612 for (uint32_t i = 0; i < pStruct->enabledExtensionCount; i++) { 1613 index_ss.str(""); 1614 index_ss << i; 1615// CODEGEN : file ../vk_helper.py line #989 1616 ss[3] << "0x" << pStruct->ppEnabledExtensionNames[i]; 1617 stp_strs[3] += " " + prefix + "ppEnabledExtensionNames[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 1618// CODEGEN : file ../vk_helper.py line #999 1619 ss[3].str(""); 1620 } 1621 } 1622// CODEGEN : file ../vk_helper.py line #1011 1623 if (pStruct->pEnabledFeatures) { 1624// CODEGEN : file ../vk_helper.py line #1023 1625 tmp_str = vk_print_vkphysicaldevicefeatures(pStruct->pEnabledFeatures, extra_indent); 1626 ss[4] << "0x" << &pStruct->pEnabledFeatures; 1627// CODEGEN : file ../vk_helper.py line #1027 1628 stp_strs[4] = " " + prefix + "pEnabledFeatures (addr)\n" + tmp_str; 1629 ss[4].str(""); 1630 } 1631 else 1632 stp_strs[4] = ""; 1633// CODEGEN : file ../vk_helper.py line #1069 1634 if (StreamControl::writeAddress) 1635 ss[0] << "0x" << pStruct->pNext; 1636 else 1637 ss[0].str("address"); 1638// CODEGEN : file ../vk_helper.py line #1085 1639 ss[1] << "0x" << pStruct->flags; 1640// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1641 ss[2] << pStruct->queueCreateInfoCount; 1642// CODEGEN : file ../vk_helper.py line #1060 1643 ss[3] << "0x" << (void*)pStruct->pQueueCreateInfos; 1644// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1645 ss[4] << pStruct->enabledLayerCount; 1646// CODEGEN : file ../vk_helper.py line #1060 1647 ss[5] << "0x" << (void*)pStruct->ppEnabledLayerNames; 1648// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1649 ss[6] << pStruct->enabledExtensionCount; 1650// CODEGEN : file ../vk_helper.py line #1060 1651 ss[7] << "0x" << (void*)pStruct->ppEnabledExtensionNames; 1652// CODEGEN : file ../vk_helper.py line #1085 1653 ss[8] << "0x" << pStruct->pEnabledFeatures; 1654// CODEGEN : file ../vk_helper.py line #1113 1655 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "queueCreateInfoCount = " + ss[2].str() + "\n" + prefix + "pQueueCreateInfos = " + ss[3].str() + "\n" + prefix + "enabledLayerCount = " + ss[4].str() + "\n" + prefix + "ppEnabledLayerNames = " + ss[5].str() + "\n" + prefix + "enabledExtensionCount = " + ss[6].str() + "\n" + prefix + "ppEnabledExtensionNames = " + ss[7].str() + "\n" + prefix + "pEnabledFeatures = " + ss[8].str() + "\n" + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 1656 return final_str; 1657} 1658// CODEGEN : file ../vk_helper.py line #906 1659std::string vk_print_vkdevicequeuecreateinfo(const VkDeviceQueueCreateInfo* pStruct, const std::string prefix) 1660{ 1661// CODEGEN : file ../vk_helper.py line #912 1662 using namespace StreamControl; 1663 using namespace std; 1664 string final_str; 1665 string tmp_str; 1666 string extra_indent = " " + prefix; 1667 stringstream ss[5]; 1668 string stp_strs[2]; 1669// CODEGEN : file ../vk_helper.py line #1011 1670 if (pStruct->pNext) { 1671// CODEGEN : file ../vk_helper.py line #1015 1672 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1673 ss[0] << "0x" << &pStruct->pNext; 1674// CODEGEN : file ../vk_helper.py line #1027 1675 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1676 ss[0].str(""); 1677 } 1678 else 1679 stp_strs[0] = ""; 1680// CODEGEN : file ../vk_helper.py line #931 1681// CODEGEN : file ../vk_helper.py line #933 1682// CODEGEN : file ../vk_helper.py line #938 1683 stp_strs[1] = ""; 1684 stringstream index_ss; 1685 if (pStruct->pQueuePriorities) { 1686 for (uint32_t i = 0; i < pStruct->queueCount; i++) { 1687 index_ss.str(""); 1688 index_ss << i; 1689// CODEGEN : file ../vk_helper.py line #989 1690 ss[1] << "0x" << pStruct->pQueuePriorities[i]; 1691 stp_strs[1] += " " + prefix + "pQueuePriorities[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 1692// CODEGEN : file ../vk_helper.py line #999 1693 ss[1].str(""); 1694 } 1695 } 1696// CODEGEN : file ../vk_helper.py line #1069 1697 if (StreamControl::writeAddress) 1698 ss[0] << "0x" << pStruct->pNext; 1699 else 1700 ss[0].str("address"); 1701// CODEGEN : file ../vk_helper.py line #1085 1702 ss[1] << "0x" << pStruct->flags; 1703// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1704 ss[2] << pStruct->queueFamilyIndex; 1705// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1706 ss[3] << pStruct->queueCount; 1707// CODEGEN : file ../vk_helper.py line #1060 1708 ss[4] << "0x" << (void*)pStruct->pQueuePriorities; 1709// CODEGEN : file ../vk_helper.py line #1113 1710 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "queueFamilyIndex = " + ss[2].str() + "\n" + prefix + "queueCount = " + ss[3].str() + "\n" + prefix + "pQueuePriorities = " + ss[4].str() + "\n" + stp_strs[1] + stp_strs[0]; 1711 return final_str; 1712} 1713// CODEGEN : file ../vk_helper.py line #906 1714std::string vk_print_vkdispatchindirectcommand(const VkDispatchIndirectCommand* pStruct, const std::string prefix) 1715{ 1716// CODEGEN : file ../vk_helper.py line #912 1717 using namespace StreamControl; 1718 using namespace std; 1719 string final_str; 1720 string tmp_str; 1721 string extra_indent = " " + prefix; 1722 stringstream ss[3]; 1723// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1724 ss[0] << pStruct->x; 1725// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1726 ss[1] << pStruct->y; 1727// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1728 ss[2] << pStruct->z; 1729// CODEGEN : file ../vk_helper.py line #1113 1730 final_str = prefix + "x = " + ss[0].str() + "\n" + prefix + "y = " + ss[1].str() + "\n" + prefix + "z = " + ss[2].str() + "\n"; 1731 return final_str; 1732} 1733// CODEGEN : file ../vk_helper.py line #906 1734std::string vk_print_vkdisplaymodecreateinfokhr(const VkDisplayModeCreateInfoKHR* pStruct, const std::string prefix) 1735{ 1736// CODEGEN : file ../vk_helper.py line #912 1737 using namespace StreamControl; 1738 using namespace std; 1739 string final_str; 1740 string tmp_str; 1741 string extra_indent = " " + prefix; 1742 stringstream ss[3]; 1743 string stp_strs[2]; 1744// CODEGEN : file ../vk_helper.py line #1011 1745 if (pStruct->pNext) { 1746// CODEGEN : file ../vk_helper.py line #1015 1747 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1748 ss[0] << "0x" << &pStruct->pNext; 1749// CODEGEN : file ../vk_helper.py line #1027 1750 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1751 ss[0].str(""); 1752 } 1753 else 1754 stp_strs[0] = ""; 1755// CODEGEN : file ../vk_helper.py line #1037 1756 tmp_str = vk_print_vkdisplaymodeparameterskhr(&pStruct->parameters, extra_indent); 1757 ss[1] << "0x" << &pStruct->parameters; 1758 stp_strs[1] = " " + prefix + "parameters (addr)\n" + tmp_str; 1759// CODEGEN : file ../vk_helper.py line #1042 1760 ss[1].str(""); 1761// CODEGEN : file ../vk_helper.py line #1069 1762 if (StreamControl::writeAddress) 1763 ss[0] << "0x" << pStruct->pNext; 1764 else 1765 ss[0].str("address"); 1766// CODEGEN : file ../vk_helper.py line #1085 1767 ss[1] << "0x" << pStruct->flags; 1768// CODEGEN : file ../vk_helper.py line #1054 1769 ss[2].str("addr"); 1770// CODEGEN : file ../vk_helper.py line #1113 1771 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "parameters = " + ss[2].str() + "\n" + stp_strs[1] + stp_strs[0]; 1772 return final_str; 1773} 1774// CODEGEN : file ../vk_helper.py line #906 1775std::string vk_print_vkdisplaymodeparameterskhr(const VkDisplayModeParametersKHR* pStruct, const std::string prefix) 1776{ 1777// CODEGEN : file ../vk_helper.py line #912 1778 using namespace StreamControl; 1779 using namespace std; 1780 string final_str; 1781 string tmp_str; 1782 string extra_indent = " " + prefix; 1783 stringstream ss[2]; 1784 string stp_strs[1]; 1785// CODEGEN : file ../vk_helper.py line #1037 1786 tmp_str = vk_print_vkextent2d(&pStruct->visibleRegion, extra_indent); 1787 ss[0] << "0x" << &pStruct->visibleRegion; 1788 stp_strs[0] = " " + prefix + "visibleRegion (addr)\n" + tmp_str; 1789// CODEGEN : file ../vk_helper.py line #1042 1790 ss[0].str(""); 1791// CODEGEN : file ../vk_helper.py line #1054 1792 ss[0].str("addr"); 1793// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1794 ss[1] << pStruct->refreshRate; 1795// CODEGEN : file ../vk_helper.py line #1113 1796 final_str = prefix + "visibleRegion = " + ss[0].str() + "\n" + prefix + "refreshRate = " + ss[1].str() + "\n" + stp_strs[0]; 1797 return final_str; 1798} 1799// CODEGEN : file ../vk_helper.py line #906 1800std::string vk_print_vkdisplaymodepropertieskhr(const VkDisplayModePropertiesKHR* pStruct, const std::string prefix) 1801{ 1802// CODEGEN : file ../vk_helper.py line #912 1803 using namespace StreamControl; 1804 using namespace std; 1805 string final_str; 1806 string tmp_str; 1807 string extra_indent = " " + prefix; 1808 stringstream ss[2]; 1809 string stp_strs[1]; 1810// CODEGEN : file ../vk_helper.py line #1037 1811 tmp_str = vk_print_vkdisplaymodeparameterskhr(&pStruct->parameters, extra_indent); 1812 ss[0] << "0x" << &pStruct->parameters; 1813 stp_strs[0] = " " + prefix + "parameters (addr)\n" + tmp_str; 1814// CODEGEN : file ../vk_helper.py line #1042 1815 ss[0].str(""); 1816// CODEGEN : file ../vk_helper.py line #1085 1817 ss[0] << "0x" << pStruct->displayMode; 1818// CODEGEN : file ../vk_helper.py line #1054 1819 ss[1].str("addr"); 1820// CODEGEN : file ../vk_helper.py line #1113 1821 final_str = prefix + "displayMode = " + ss[0].str() + "\n" + prefix + "parameters = " + ss[1].str() + "\n" + stp_strs[0]; 1822 return final_str; 1823} 1824// CODEGEN : file ../vk_helper.py line #906 1825std::string vk_print_vkdisplayplanecapabilitieskhr(const VkDisplayPlaneCapabilitiesKHR* pStruct, const std::string prefix) 1826{ 1827// CODEGEN : file ../vk_helper.py line #912 1828 using namespace StreamControl; 1829 using namespace std; 1830 string final_str; 1831 string tmp_str; 1832 string extra_indent = " " + prefix; 1833 stringstream ss[9]; 1834 string stp_strs[8]; 1835// CODEGEN : file ../vk_helper.py line #1037 1836 tmp_str = vk_print_vkoffset2d(&pStruct->minSrcPosition, extra_indent); 1837 ss[0] << "0x" << &pStruct->minSrcPosition; 1838 stp_strs[0] = " " + prefix + "minSrcPosition (addr)\n" + tmp_str; 1839// CODEGEN : file ../vk_helper.py line #1042 1840 ss[0].str(""); 1841// CODEGEN : file ../vk_helper.py line #1037 1842 tmp_str = vk_print_vkoffset2d(&pStruct->maxSrcPosition, extra_indent); 1843 ss[1] << "0x" << &pStruct->maxSrcPosition; 1844 stp_strs[1] = " " + prefix + "maxSrcPosition (addr)\n" + tmp_str; 1845// CODEGEN : file ../vk_helper.py line #1042 1846 ss[1].str(""); 1847// CODEGEN : file ../vk_helper.py line #1037 1848 tmp_str = vk_print_vkextent2d(&pStruct->minSrcExtent, extra_indent); 1849 ss[2] << "0x" << &pStruct->minSrcExtent; 1850 stp_strs[2] = " " + prefix + "minSrcExtent (addr)\n" + tmp_str; 1851// CODEGEN : file ../vk_helper.py line #1042 1852 ss[2].str(""); 1853// CODEGEN : file ../vk_helper.py line #1037 1854 tmp_str = vk_print_vkextent2d(&pStruct->maxSrcExtent, extra_indent); 1855 ss[3] << "0x" << &pStruct->maxSrcExtent; 1856 stp_strs[3] = " " + prefix + "maxSrcExtent (addr)\n" + tmp_str; 1857// CODEGEN : file ../vk_helper.py line #1042 1858 ss[3].str(""); 1859// CODEGEN : file ../vk_helper.py line #1037 1860 tmp_str = vk_print_vkoffset2d(&pStruct->minDstPosition, extra_indent); 1861 ss[4] << "0x" << &pStruct->minDstPosition; 1862 stp_strs[4] = " " + prefix + "minDstPosition (addr)\n" + tmp_str; 1863// CODEGEN : file ../vk_helper.py line #1042 1864 ss[4].str(""); 1865// CODEGEN : file ../vk_helper.py line #1037 1866 tmp_str = vk_print_vkoffset2d(&pStruct->maxDstPosition, extra_indent); 1867 ss[5] << "0x" << &pStruct->maxDstPosition; 1868 stp_strs[5] = " " + prefix + "maxDstPosition (addr)\n" + tmp_str; 1869// CODEGEN : file ../vk_helper.py line #1042 1870 ss[5].str(""); 1871// CODEGEN : file ../vk_helper.py line #1037 1872 tmp_str = vk_print_vkextent2d(&pStruct->minDstExtent, extra_indent); 1873 ss[6] << "0x" << &pStruct->minDstExtent; 1874 stp_strs[6] = " " + prefix + "minDstExtent (addr)\n" + tmp_str; 1875// CODEGEN : file ../vk_helper.py line #1042 1876 ss[6].str(""); 1877// CODEGEN : file ../vk_helper.py line #1037 1878 tmp_str = vk_print_vkextent2d(&pStruct->maxDstExtent, extra_indent); 1879 ss[7] << "0x" << &pStruct->maxDstExtent; 1880 stp_strs[7] = " " + prefix + "maxDstExtent (addr)\n" + tmp_str; 1881// CODEGEN : file ../vk_helper.py line #1042 1882 ss[7].str(""); 1883// CODEGEN : file ../vk_helper.py line #1085 1884 ss[0] << "0x" << pStruct->supportedAlpha; 1885// CODEGEN : file ../vk_helper.py line #1054 1886 ss[1].str("addr"); 1887// CODEGEN : file ../vk_helper.py line #1054 1888 ss[2].str("addr"); 1889// CODEGEN : file ../vk_helper.py line #1054 1890 ss[3].str("addr"); 1891// CODEGEN : file ../vk_helper.py line #1054 1892 ss[4].str("addr"); 1893// CODEGEN : file ../vk_helper.py line #1054 1894 ss[5].str("addr"); 1895// CODEGEN : file ../vk_helper.py line #1054 1896 ss[6].str("addr"); 1897// CODEGEN : file ../vk_helper.py line #1054 1898 ss[7].str("addr"); 1899// CODEGEN : file ../vk_helper.py line #1054 1900 ss[8].str("addr"); 1901// CODEGEN : file ../vk_helper.py line #1113 1902 final_str = prefix + "supportedAlpha = " + ss[0].str() + "\n" + prefix + "minSrcPosition = " + ss[1].str() + "\n" + prefix + "maxSrcPosition = " + ss[2].str() + "\n" + prefix + "minSrcExtent = " + ss[3].str() + "\n" + prefix + "maxSrcExtent = " + ss[4].str() + "\n" + prefix + "minDstPosition = " + ss[5].str() + "\n" + prefix + "maxDstPosition = " + ss[6].str() + "\n" + prefix + "minDstExtent = " + ss[7].str() + "\n" + prefix + "maxDstExtent = " + ss[8].str() + "\n" + stp_strs[7] + stp_strs[6] + stp_strs[5] + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 1903 return final_str; 1904} 1905// CODEGEN : file ../vk_helper.py line #906 1906std::string vk_print_vkdisplayplanepropertieskhr(const VkDisplayPlanePropertiesKHR* pStruct, const std::string prefix) 1907{ 1908// CODEGEN : file ../vk_helper.py line #912 1909 using namespace StreamControl; 1910 using namespace std; 1911 string final_str; 1912 string tmp_str; 1913 string extra_indent = " " + prefix; 1914 stringstream ss[2]; 1915// CODEGEN : file ../vk_helper.py line #1085 1916 ss[0] << "0x" << pStruct->currentDisplay; 1917// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 1918 ss[1] << pStruct->currentStackIndex; 1919// CODEGEN : file ../vk_helper.py line #1113 1920 final_str = prefix + "currentDisplay = " + ss[0].str() + "\n" + prefix + "currentStackIndex = " + ss[1].str() + "\n"; 1921 return final_str; 1922} 1923// CODEGEN : file ../vk_helper.py line #906 1924std::string vk_print_vkdisplaypresentinfokhr(const VkDisplayPresentInfoKHR* pStruct, const std::string prefix) 1925{ 1926// CODEGEN : file ../vk_helper.py line #912 1927 using namespace StreamControl; 1928 using namespace std; 1929 string final_str; 1930 string tmp_str; 1931 string extra_indent = " " + prefix; 1932 stringstream ss[4]; 1933 string stp_strs[3]; 1934// CODEGEN : file ../vk_helper.py line #1011 1935 if (pStruct->pNext) { 1936// CODEGEN : file ../vk_helper.py line #1015 1937 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1938 ss[0] << "0x" << &pStruct->pNext; 1939// CODEGEN : file ../vk_helper.py line #1027 1940 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1941 ss[0].str(""); 1942 } 1943 else 1944 stp_strs[0] = ""; 1945// CODEGEN : file ../vk_helper.py line #1037 1946 tmp_str = vk_print_vkrect2d(&pStruct->srcRect, extra_indent); 1947 ss[1] << "0x" << &pStruct->srcRect; 1948 stp_strs[1] = " " + prefix + "srcRect (addr)\n" + tmp_str; 1949// CODEGEN : file ../vk_helper.py line #1042 1950 ss[1].str(""); 1951// CODEGEN : file ../vk_helper.py line #1037 1952 tmp_str = vk_print_vkrect2d(&pStruct->dstRect, extra_indent); 1953 ss[2] << "0x" << &pStruct->dstRect; 1954 stp_strs[2] = " " + prefix + "dstRect (addr)\n" + tmp_str; 1955// CODEGEN : file ../vk_helper.py line #1042 1956 ss[2].str(""); 1957// CODEGEN : file ../vk_helper.py line #1069 1958 if (StreamControl::writeAddress) 1959 ss[0] << "0x" << pStruct->pNext; 1960 else 1961 ss[0].str("address"); 1962// CODEGEN : file ../vk_helper.py line #1054 1963 ss[1].str("addr"); 1964// CODEGEN : file ../vk_helper.py line #1054 1965 ss[2].str("addr"); 1966// CODEGEN : file ../vk_helper.py line #1063 1967 ss[3].str(pStruct->persistent ? "TRUE" : "FALSE"); 1968// CODEGEN : file ../vk_helper.py line #1113 1969 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "srcRect = " + ss[1].str() + "\n" + prefix + "dstRect = " + ss[2].str() + "\n" + prefix + "persistent = " + ss[3].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 1970 return final_str; 1971} 1972// CODEGEN : file ../vk_helper.py line #906 1973std::string vk_print_vkdisplaypropertieskhr(const VkDisplayPropertiesKHR* pStruct, const std::string prefix) 1974{ 1975// CODEGEN : file ../vk_helper.py line #912 1976 using namespace StreamControl; 1977 using namespace std; 1978 string final_str; 1979 string tmp_str; 1980 string extra_indent = " " + prefix; 1981 stringstream ss[7]; 1982 string stp_strs[2]; 1983// CODEGEN : file ../vk_helper.py line #1037 1984 tmp_str = vk_print_vkextent2d(&pStruct->physicalDimensions, extra_indent); 1985 ss[0] << "0x" << &pStruct->physicalDimensions; 1986 stp_strs[0] = " " + prefix + "physicalDimensions (addr)\n" + tmp_str; 1987// CODEGEN : file ../vk_helper.py line #1042 1988 ss[0].str(""); 1989// CODEGEN : file ../vk_helper.py line #1037 1990 tmp_str = vk_print_vkextent2d(&pStruct->physicalResolution, extra_indent); 1991 ss[1] << "0x" << &pStruct->physicalResolution; 1992 stp_strs[1] = " " + prefix + "physicalResolution (addr)\n" + tmp_str; 1993// CODEGEN : file ../vk_helper.py line #1042 1994 ss[1].str(""); 1995// CODEGEN : file ../vk_helper.py line #1085 1996 ss[0] << "0x" << pStruct->display; 1997// CODEGEN : file ../vk_helper.py line #1075 1998 if (pStruct->displayName != NULL) { 1999 ss[1] << pStruct->displayName; 2000 } else { 2001 ss[1] << ""; 2002 } 2003// CODEGEN : file ../vk_helper.py line #1054 2004 ss[2].str("addr"); 2005// CODEGEN : file ../vk_helper.py line #1054 2006 ss[3].str("addr"); 2007// CODEGEN : file ../vk_helper.py line #1085 2008 ss[4] << "0x" << pStruct->supportedTransforms; 2009// CODEGEN : file ../vk_helper.py line #1063 2010 ss[5].str(pStruct->planeReorderPossible ? "TRUE" : "FALSE"); 2011// CODEGEN : file ../vk_helper.py line #1063 2012 ss[6].str(pStruct->persistentContent ? "TRUE" : "FALSE"); 2013// CODEGEN : file ../vk_helper.py line #1113 2014 final_str = prefix + "display = " + ss[0].str() + "\n" + prefix + "displayName = " + ss[1].str() + "\n" + prefix + "physicalDimensions = " + ss[2].str() + "\n" + prefix + "physicalResolution = " + ss[3].str() + "\n" + prefix + "supportedTransforms = " + ss[4].str() + "\n" + prefix + "planeReorderPossible = " + ss[5].str() + "\n" + prefix + "persistentContent = " + ss[6].str() + "\n" + stp_strs[1] + stp_strs[0]; 2015 return final_str; 2016} 2017// CODEGEN : file ../vk_helper.py line #906 2018std::string vk_print_vkdisplaysurfacecreateinfokhr(const VkDisplaySurfaceCreateInfoKHR* pStruct, const std::string prefix) 2019{ 2020// CODEGEN : file ../vk_helper.py line #912 2021 using namespace StreamControl; 2022 using namespace std; 2023 string final_str; 2024 string tmp_str; 2025 string extra_indent = " " + prefix; 2026 stringstream ss[7]; 2027 string stp_strs[2]; 2028// CODEGEN : file ../vk_helper.py line #1011 2029 if (pStruct->pNext) { 2030// CODEGEN : file ../vk_helper.py line #1015 2031 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2032 ss[0] << "0x" << &pStruct->pNext; 2033// CODEGEN : file ../vk_helper.py line #1027 2034 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2035 ss[0].str(""); 2036 } 2037 else 2038 stp_strs[0] = ""; 2039// CODEGEN : file ../vk_helper.py line #1037 2040 tmp_str = vk_print_vkextent2d(&pStruct->imageExtent, extra_indent); 2041 ss[1] << "0x" << &pStruct->imageExtent; 2042 stp_strs[1] = " " + prefix + "imageExtent (addr)\n" + tmp_str; 2043// CODEGEN : file ../vk_helper.py line #1042 2044 ss[1].str(""); 2045// CODEGEN : file ../vk_helper.py line #1069 2046 if (StreamControl::writeAddress) 2047 ss[0] << "0x" << pStruct->pNext; 2048 else 2049 ss[0].str("address"); 2050// CODEGEN : file ../vk_helper.py line #1085 2051 ss[1] << "0x" << pStruct->flags; 2052// CODEGEN : file ../vk_helper.py line #1085 2053 ss[2] << "0x" << pStruct->displayMode; 2054// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2055 ss[3] << pStruct->planeIndex; 2056// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2057 ss[4] << pStruct->planeStackIndex; 2058// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2059 ss[5] << pStruct->globalAlpha; 2060// CODEGEN : file ../vk_helper.py line #1054 2061 ss[6].str("addr"); 2062// CODEGEN : file ../vk_helper.py line #1113 2063 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "displayMode = " + ss[2].str() + "\n" + prefix + "planeIndex = " + ss[3].str() + "\n" + prefix + "planeStackIndex = " + ss[4].str() + "\n" + prefix + "transform = " + string_VkSurfaceTransformFlagBitsKHR(pStruct->transform) + "\n" + prefix + "globalAlpha = " + ss[5].str() + "\n" + prefix + "alphaMode = " + string_VkDisplayPlaneAlphaFlagBitsKHR(pStruct->alphaMode) + "\n" + prefix + "imageExtent = " + ss[6].str() + "\n" + stp_strs[1] + stp_strs[0]; 2064 return final_str; 2065} 2066// CODEGEN : file ../vk_helper.py line #906 2067std::string vk_print_vkdrawindexedindirectcommand(const VkDrawIndexedIndirectCommand* pStruct, const std::string prefix) 2068{ 2069// CODEGEN : file ../vk_helper.py line #912 2070 using namespace StreamControl; 2071 using namespace std; 2072 string final_str; 2073 string tmp_str; 2074 string extra_indent = " " + prefix; 2075 stringstream ss[5]; 2076// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2077 ss[0] << pStruct->indexCount; 2078// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2079 ss[1] << pStruct->instanceCount; 2080// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2081 ss[2] << pStruct->firstIndex; 2082// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 2083 ss[3] << "0x" << pStruct->vertexOffset; 2084// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2085 ss[4] << pStruct->firstInstance; 2086// CODEGEN : file ../vk_helper.py line #1113 2087 final_str = prefix + "indexCount = " + ss[0].str() + "\n" + prefix + "instanceCount = " + ss[1].str() + "\n" + prefix + "firstIndex = " + ss[2].str() + "\n" + prefix + "vertexOffset = " + ss[3].str() + "\n" + prefix + "firstInstance = " + ss[4].str() + "\n"; 2088 return final_str; 2089} 2090// CODEGEN : file ../vk_helper.py line #906 2091std::string vk_print_vkdrawindirectcommand(const VkDrawIndirectCommand* pStruct, const std::string prefix) 2092{ 2093// CODEGEN : file ../vk_helper.py line #912 2094 using namespace StreamControl; 2095 using namespace std; 2096 string final_str; 2097 string tmp_str; 2098 string extra_indent = " " + prefix; 2099 stringstream ss[4]; 2100// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2101 ss[0] << pStruct->vertexCount; 2102// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2103 ss[1] << pStruct->instanceCount; 2104// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2105 ss[2] << pStruct->firstVertex; 2106// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2107 ss[3] << pStruct->firstInstance; 2108// CODEGEN : file ../vk_helper.py line #1113 2109 final_str = prefix + "vertexCount = " + ss[0].str() + "\n" + prefix + "instanceCount = " + ss[1].str() + "\n" + prefix + "firstVertex = " + ss[2].str() + "\n" + prefix + "firstInstance = " + ss[3].str() + "\n"; 2110 return final_str; 2111} 2112// CODEGEN : file ../vk_helper.py line #906 2113std::string vk_print_vkeventcreateinfo(const VkEventCreateInfo* pStruct, const std::string prefix) 2114{ 2115// CODEGEN : file ../vk_helper.py line #912 2116 using namespace StreamControl; 2117 using namespace std; 2118 string final_str; 2119 string tmp_str; 2120 string extra_indent = " " + prefix; 2121 stringstream ss[2]; 2122 string stp_strs[1]; 2123// CODEGEN : file ../vk_helper.py line #1011 2124 if (pStruct->pNext) { 2125// CODEGEN : file ../vk_helper.py line #1015 2126 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2127 ss[0] << "0x" << &pStruct->pNext; 2128// CODEGEN : file ../vk_helper.py line #1027 2129 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2130 ss[0].str(""); 2131 } 2132 else 2133 stp_strs[0] = ""; 2134// CODEGEN : file ../vk_helper.py line #1069 2135 if (StreamControl::writeAddress) 2136 ss[0] << "0x" << pStruct->pNext; 2137 else 2138 ss[0].str("address"); 2139// CODEGEN : file ../vk_helper.py line #1085 2140 ss[1] << "0x" << pStruct->flags; 2141// CODEGEN : file ../vk_helper.py line #1113 2142 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + stp_strs[0]; 2143 return final_str; 2144} 2145// CODEGEN : file ../vk_helper.py line #906 2146std::string vk_print_vkextensionproperties(const VkExtensionProperties* pStruct, const std::string prefix) 2147{ 2148// CODEGEN : file ../vk_helper.py line #912 2149 using namespace StreamControl; 2150 using namespace std; 2151 string final_str; 2152 string tmp_str; 2153 string extra_indent = " " + prefix; 2154 stringstream ss[2]; 2155 string stp_strs[1]; 2156// CODEGEN : file ../vk_helper.py line #931 2157// CODEGEN : file ../vk_helper.py line #936 2158// CODEGEN : file ../vk_helper.py line #938 2159 stp_strs[0] = ""; 2160 stringstream index_ss; 2161 for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) { 2162 index_ss.str(""); 2163 index_ss << i; 2164// CODEGEN : file ../vk_helper.py line #989 2165 ss[0] << pStruct->extensionName[i]; 2166 stp_strs[0] += " " + prefix + "extensionName[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 2167// CODEGEN : file ../vk_helper.py line #999 2168 ss[0].str(""); 2169 } 2170// CODEGEN : file ../vk_helper.py line #1060 2171 ss[0] << "0x" << (void*)pStruct->extensionName; 2172// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2173 ss[1] << pStruct->specVersion; 2174// CODEGEN : file ../vk_helper.py line #1113 2175 final_str = prefix + "extensionName = " + ss[0].str() + "\n" + prefix + "specVersion = " + ss[1].str() + "\n" + stp_strs[0]; 2176 return final_str; 2177} 2178// CODEGEN : file ../vk_helper.py line #906 2179std::string vk_print_vkextent2d(const VkExtent2D* pStruct, const std::string prefix) 2180{ 2181// CODEGEN : file ../vk_helper.py line #912 2182 using namespace StreamControl; 2183 using namespace std; 2184 string final_str; 2185 string tmp_str; 2186 string extra_indent = " " + prefix; 2187 stringstream ss[2]; 2188// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2189 ss[0] << pStruct->width; 2190// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2191 ss[1] << pStruct->height; 2192// CODEGEN : file ../vk_helper.py line #1113 2193 final_str = prefix + "width = " + ss[0].str() + "\n" + prefix + "height = " + ss[1].str() + "\n"; 2194 return final_str; 2195} 2196// CODEGEN : file ../vk_helper.py line #906 2197std::string vk_print_vkextent3d(const VkExtent3D* pStruct, const std::string prefix) 2198{ 2199// CODEGEN : file ../vk_helper.py line #912 2200 using namespace StreamControl; 2201 using namespace std; 2202 string final_str; 2203 string tmp_str; 2204 string extra_indent = " " + prefix; 2205 stringstream ss[3]; 2206// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2207 ss[0] << pStruct->width; 2208// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2209 ss[1] << pStruct->height; 2210// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2211 ss[2] << pStruct->depth; 2212// CODEGEN : file ../vk_helper.py line #1113 2213 final_str = prefix + "width = " + ss[0].str() + "\n" + prefix + "height = " + ss[1].str() + "\n" + prefix + "depth = " + ss[2].str() + "\n"; 2214 return final_str; 2215} 2216// CODEGEN : file ../vk_helper.py line #906 2217std::string vk_print_vkfencecreateinfo(const VkFenceCreateInfo* pStruct, const std::string prefix) 2218{ 2219// CODEGEN : file ../vk_helper.py line #912 2220 using namespace StreamControl; 2221 using namespace std; 2222 string final_str; 2223 string tmp_str; 2224 string extra_indent = " " + prefix; 2225 stringstream ss[2]; 2226 string stp_strs[1]; 2227// CODEGEN : file ../vk_helper.py line #1011 2228 if (pStruct->pNext) { 2229// CODEGEN : file ../vk_helper.py line #1015 2230 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2231 ss[0] << "0x" << &pStruct->pNext; 2232// CODEGEN : file ../vk_helper.py line #1027 2233 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2234 ss[0].str(""); 2235 } 2236 else 2237 stp_strs[0] = ""; 2238// CODEGEN : file ../vk_helper.py line #1069 2239 if (StreamControl::writeAddress) 2240 ss[0] << "0x" << pStruct->pNext; 2241 else 2242 ss[0].str("address"); 2243// CODEGEN : file ../vk_helper.py line #1085 2244 ss[1] << "0x" << pStruct->flags; 2245// CODEGEN : file ../vk_helper.py line #1113 2246 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + stp_strs[0]; 2247 return final_str; 2248} 2249// CODEGEN : file ../vk_helper.py line #906 2250std::string vk_print_vkformatproperties(const VkFormatProperties* pStruct, const std::string prefix) 2251{ 2252// CODEGEN : file ../vk_helper.py line #912 2253 using namespace StreamControl; 2254 using namespace std; 2255 string final_str; 2256 string tmp_str; 2257 string extra_indent = " " + prefix; 2258 stringstream ss[3]; 2259// CODEGEN : file ../vk_helper.py line #1085 2260 ss[0] << "0x" << pStruct->linearTilingFeatures; 2261// CODEGEN : file ../vk_helper.py line #1085 2262 ss[1] << "0x" << pStruct->optimalTilingFeatures; 2263// CODEGEN : file ../vk_helper.py line #1085 2264 ss[2] << "0x" << pStruct->bufferFeatures; 2265// CODEGEN : file ../vk_helper.py line #1113 2266 final_str = prefix + "linearTilingFeatures = " + ss[0].str() + "\n" + prefix + "optimalTilingFeatures = " + ss[1].str() + "\n" + prefix + "bufferFeatures = " + ss[2].str() + "\n"; 2267 return final_str; 2268} 2269// CODEGEN : file ../vk_helper.py line #906 2270std::string vk_print_vkframebuffercreateinfo(const VkFramebufferCreateInfo* pStruct, const std::string prefix) 2271{ 2272// CODEGEN : file ../vk_helper.py line #912 2273 using namespace StreamControl; 2274 using namespace std; 2275 string final_str; 2276 string tmp_str; 2277 string extra_indent = " " + prefix; 2278 stringstream ss[8]; 2279 string stp_strs[2]; 2280// CODEGEN : file ../vk_helper.py line #1011 2281 if (pStruct->pNext) { 2282// CODEGEN : file ../vk_helper.py line #1015 2283 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2284 ss[0] << "0x" << &pStruct->pNext; 2285// CODEGEN : file ../vk_helper.py line #1027 2286 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2287 ss[0].str(""); 2288 } 2289 else 2290 stp_strs[0] = ""; 2291// CODEGEN : file ../vk_helper.py line #931 2292// CODEGEN : file ../vk_helper.py line #933 2293// CODEGEN : file ../vk_helper.py line #938 2294 stp_strs[1] = ""; 2295 stringstream index_ss; 2296 if (pStruct->pAttachments) { 2297 for (uint32_t i = 0; i < pStruct->attachmentCount; i++) { 2298 index_ss.str(""); 2299 index_ss << i; 2300// CODEGEN : file ../vk_helper.py line #989 2301 ss[1] << "0x" << pStruct->pAttachments[i]; 2302 stp_strs[1] += " " + prefix + "pAttachments[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 2303// CODEGEN : file ../vk_helper.py line #999 2304 ss[1].str(""); 2305 } 2306 } 2307// CODEGEN : file ../vk_helper.py line #1069 2308 if (StreamControl::writeAddress) 2309 ss[0] << "0x" << pStruct->pNext; 2310 else 2311 ss[0].str("address"); 2312// CODEGEN : file ../vk_helper.py line #1085 2313 ss[1] << "0x" << pStruct->flags; 2314// CODEGEN : file ../vk_helper.py line #1085 2315 ss[2] << "0x" << pStruct->renderPass; 2316// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2317 ss[3] << pStruct->attachmentCount; 2318// CODEGEN : file ../vk_helper.py line #1060 2319 ss[4] << "0x" << (void*)pStruct->pAttachments; 2320// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2321 ss[5] << pStruct->width; 2322// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2323 ss[6] << pStruct->height; 2324// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2325 ss[7] << pStruct->layers; 2326// CODEGEN : file ../vk_helper.py line #1113 2327 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "renderPass = " + ss[2].str() + "\n" + prefix + "attachmentCount = " + ss[3].str() + "\n" + prefix + "pAttachments = " + ss[4].str() + "\n" + prefix + "width = " + ss[5].str() + "\n" + prefix + "height = " + ss[6].str() + "\n" + prefix + "layers = " + ss[7].str() + "\n" + stp_strs[1] + stp_strs[0]; 2328 return final_str; 2329} 2330// CODEGEN : file ../vk_helper.py line #906 2331std::string vk_print_vkgraphicspipelinecreateinfo(const VkGraphicsPipelineCreateInfo* pStruct, const std::string prefix) 2332{ 2333// CODEGEN : file ../vk_helper.py line #912 2334 using namespace StreamControl; 2335 using namespace std; 2336 string final_str; 2337 string tmp_str; 2338 string extra_indent = " " + prefix; 2339 stringstream ss[18]; 2340 string stp_strs[11]; 2341// CODEGEN : file ../vk_helper.py line #1011 2342 if (pStruct->pNext) { 2343// CODEGEN : file ../vk_helper.py line #1015 2344 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2345 ss[0] << "0x" << &pStruct->pNext; 2346// CODEGEN : file ../vk_helper.py line #1027 2347 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2348 ss[0].str(""); 2349 } 2350 else 2351 stp_strs[0] = ""; 2352// CODEGEN : file ../vk_helper.py line #931 2353// CODEGEN : file ../vk_helper.py line #933 2354// CODEGEN : file ../vk_helper.py line #938 2355 stp_strs[1] = ""; 2356 stringstream index_ss; 2357 if (pStruct->pStages) { 2358 for (uint32_t i = 0; i < pStruct->stageCount; i++) { 2359 index_ss.str(""); 2360 index_ss << i; 2361// CODEGEN : file ../vk_helper.py line #979 2362 ss[1] << "0x" << &pStruct->pStages[i]; 2363 tmp_str = vk_print_vkpipelineshaderstagecreateinfo(&pStruct->pStages[i], extra_indent); 2364// CODEGEN : file ../vk_helper.py line #983 2365 stp_strs[1] += " " + prefix + "pStages[" + index_ss.str() + "] (addr)\n" + tmp_str; 2366// CODEGEN : file ../vk_helper.py line #999 2367 ss[1].str(""); 2368 } 2369 } 2370// CODEGEN : file ../vk_helper.py line #1011 2371 if (pStruct->pVertexInputState) { 2372// CODEGEN : file ../vk_helper.py line #1023 2373 tmp_str = vk_print_vkpipelinevertexinputstatecreateinfo(pStruct->pVertexInputState, extra_indent); 2374 ss[2] << "0x" << &pStruct->pVertexInputState; 2375// CODEGEN : file ../vk_helper.py line #1027 2376 stp_strs[2] = " " + prefix + "pVertexInputState (addr)\n" + tmp_str; 2377 ss[2].str(""); 2378 } 2379 else 2380 stp_strs[2] = ""; 2381// CODEGEN : file ../vk_helper.py line #1011 2382 if (pStruct->pInputAssemblyState) { 2383// CODEGEN : file ../vk_helper.py line #1023 2384 tmp_str = vk_print_vkpipelineinputassemblystatecreateinfo(pStruct->pInputAssemblyState, extra_indent); 2385 ss[3] << "0x" << &pStruct->pInputAssemblyState; 2386// CODEGEN : file ../vk_helper.py line #1027 2387 stp_strs[3] = " " + prefix + "pInputAssemblyState (addr)\n" + tmp_str; 2388 ss[3].str(""); 2389 } 2390 else 2391 stp_strs[3] = ""; 2392// CODEGEN : file ../vk_helper.py line #1011 2393 if (pStruct->pTessellationState) { 2394// CODEGEN : file ../vk_helper.py line #1023 2395 tmp_str = vk_print_vkpipelinetessellationstatecreateinfo(pStruct->pTessellationState, extra_indent); 2396 ss[4] << "0x" << &pStruct->pTessellationState; 2397// CODEGEN : file ../vk_helper.py line #1027 2398 stp_strs[4] = " " + prefix + "pTessellationState (addr)\n" + tmp_str; 2399 ss[4].str(""); 2400 } 2401 else 2402 stp_strs[4] = ""; 2403// CODEGEN : file ../vk_helper.py line #1011 2404 if (pStruct->pViewportState) { 2405// CODEGEN : file ../vk_helper.py line #1023 2406 tmp_str = vk_print_vkpipelineviewportstatecreateinfo(pStruct->pViewportState, extra_indent); 2407 ss[5] << "0x" << &pStruct->pViewportState; 2408// CODEGEN : file ../vk_helper.py line #1027 2409 stp_strs[5] = " " + prefix + "pViewportState (addr)\n" + tmp_str; 2410 ss[5].str(""); 2411 } 2412 else 2413 stp_strs[5] = ""; 2414// CODEGEN : file ../vk_helper.py line #1011 2415 if (pStruct->pRasterizationState) { 2416// CODEGEN : file ../vk_helper.py line #1023 2417 tmp_str = vk_print_vkpipelinerasterizationstatecreateinfo(pStruct->pRasterizationState, extra_indent); 2418 ss[6] << "0x" << &pStruct->pRasterizationState; 2419// CODEGEN : file ../vk_helper.py line #1027 2420 stp_strs[6] = " " + prefix + "pRasterizationState (addr)\n" + tmp_str; 2421 ss[6].str(""); 2422 } 2423 else 2424 stp_strs[6] = ""; 2425// CODEGEN : file ../vk_helper.py line #1011 2426 if (pStruct->pMultisampleState) { 2427// CODEGEN : file ../vk_helper.py line #1023 2428 tmp_str = vk_print_vkpipelinemultisamplestatecreateinfo(pStruct->pMultisampleState, extra_indent); 2429 ss[7] << "0x" << &pStruct->pMultisampleState; 2430// CODEGEN : file ../vk_helper.py line #1027 2431 stp_strs[7] = " " + prefix + "pMultisampleState (addr)\n" + tmp_str; 2432 ss[7].str(""); 2433 } 2434 else 2435 stp_strs[7] = ""; 2436// CODEGEN : file ../vk_helper.py line #1011 2437 if (pStruct->pDepthStencilState) { 2438// CODEGEN : file ../vk_helper.py line #1023 2439 tmp_str = vk_print_vkpipelinedepthstencilstatecreateinfo(pStruct->pDepthStencilState, extra_indent); 2440 ss[8] << "0x" << &pStruct->pDepthStencilState; 2441// CODEGEN : file ../vk_helper.py line #1027 2442 stp_strs[8] = " " + prefix + "pDepthStencilState (addr)\n" + tmp_str; 2443 ss[8].str(""); 2444 } 2445 else 2446 stp_strs[8] = ""; 2447// CODEGEN : file ../vk_helper.py line #1011 2448 if (pStruct->pColorBlendState) { 2449// CODEGEN : file ../vk_helper.py line #1023 2450 tmp_str = vk_print_vkpipelinecolorblendstatecreateinfo(pStruct->pColorBlendState, extra_indent); 2451 ss[9] << "0x" << &pStruct->pColorBlendState; 2452// CODEGEN : file ../vk_helper.py line #1027 2453 stp_strs[9] = " " + prefix + "pColorBlendState (addr)\n" + tmp_str; 2454 ss[9].str(""); 2455 } 2456 else 2457 stp_strs[9] = ""; 2458// CODEGEN : file ../vk_helper.py line #1011 2459 if (pStruct->pDynamicState) { 2460// CODEGEN : file ../vk_helper.py line #1023 2461 tmp_str = vk_print_vkpipelinedynamicstatecreateinfo(pStruct->pDynamicState, extra_indent); 2462 ss[10] << "0x" << &pStruct->pDynamicState; 2463// CODEGEN : file ../vk_helper.py line #1027 2464 stp_strs[10] = " " + prefix + "pDynamicState (addr)\n" + tmp_str; 2465 ss[10].str(""); 2466 } 2467 else 2468 stp_strs[10] = ""; 2469// CODEGEN : file ../vk_helper.py line #1069 2470 if (StreamControl::writeAddress) 2471 ss[0] << "0x" << pStruct->pNext; 2472 else 2473 ss[0].str("address"); 2474// CODEGEN : file ../vk_helper.py line #1085 2475 ss[1] << "0x" << pStruct->flags; 2476// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2477 ss[2] << pStruct->stageCount; 2478// CODEGEN : file ../vk_helper.py line #1060 2479 ss[3] << "0x" << (void*)pStruct->pStages; 2480// CODEGEN : file ../vk_helper.py line #1085 2481 ss[4] << "0x" << pStruct->pVertexInputState; 2482// CODEGEN : file ../vk_helper.py line #1085 2483 ss[5] << "0x" << pStruct->pInputAssemblyState; 2484// CODEGEN : file ../vk_helper.py line #1085 2485 ss[6] << "0x" << pStruct->pTessellationState; 2486// CODEGEN : file ../vk_helper.py line #1085 2487 ss[7] << "0x" << pStruct->pViewportState; 2488// CODEGEN : file ../vk_helper.py line #1085 2489 ss[8] << "0x" << pStruct->pRasterizationState; 2490// CODEGEN : file ../vk_helper.py line #1085 2491 ss[9] << "0x" << pStruct->pMultisampleState; 2492// CODEGEN : file ../vk_helper.py line #1085 2493 ss[10] << "0x" << pStruct->pDepthStencilState; 2494// CODEGEN : file ../vk_helper.py line #1085 2495 ss[11] << "0x" << pStruct->pColorBlendState; 2496// CODEGEN : file ../vk_helper.py line #1085 2497 ss[12] << "0x" << pStruct->pDynamicState; 2498// CODEGEN : file ../vk_helper.py line #1085 2499 ss[13] << "0x" << pStruct->layout; 2500// CODEGEN : file ../vk_helper.py line #1085 2501 ss[14] << "0x" << pStruct->renderPass; 2502// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2503 ss[15] << pStruct->subpass; 2504// CODEGEN : file ../vk_helper.py line #1085 2505 ss[16] << "0x" << pStruct->basePipelineHandle; 2506// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2507 ss[17] << pStruct->basePipelineIndex; 2508// CODEGEN : file ../vk_helper.py line #1113 2509 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "stageCount = " + ss[2].str() + "\n" + prefix + "pStages = " + ss[3].str() + "\n" + prefix + "pVertexInputState = " + ss[4].str() + "\n" + prefix + "pInputAssemblyState = " + ss[5].str() + "\n" + prefix + "pTessellationState = " + ss[6].str() + "\n" + prefix + "pViewportState = " + ss[7].str() + "\n" + prefix + "pRasterizationState = " + ss[8].str() + "\n" + prefix + "pMultisampleState = " + ss[9].str() + "\n" + prefix + "pDepthStencilState = " + ss[10].str() + "\n" + prefix + "pColorBlendState = " + ss[11].str() + "\n" + prefix + "pDynamicState = " + ss[12].str() + "\n" + prefix + "layout = " + ss[13].str() + "\n" + prefix + "renderPass = " + ss[14].str() + "\n" + prefix + "subpass = " + ss[15].str() + "\n" + prefix + "basePipelineHandle = " + ss[16].str() + "\n" + prefix + "basePipelineIndex = " + ss[17].str() + "\n" + stp_strs[10] + stp_strs[9] + stp_strs[8] + stp_strs[7] + stp_strs[6] + stp_strs[5] + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 2510 return final_str; 2511} 2512// CODEGEN : file ../vk_helper.py line #906 2513std::string vk_print_vkimageblit(const VkImageBlit* pStruct, const std::string prefix) 2514{ 2515// CODEGEN : file ../vk_helper.py line #912 2516 using namespace StreamControl; 2517 using namespace std; 2518 string final_str; 2519 string tmp_str; 2520 string extra_indent = " " + prefix; 2521 stringstream ss[4]; 2522 string stp_strs[4]; 2523// CODEGEN : file ../vk_helper.py line #1037 2524 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->srcSubresource, extra_indent); 2525 ss[0] << "0x" << &pStruct->srcSubresource; 2526 stp_strs[0] = " " + prefix + "srcSubresource (addr)\n" + tmp_str; 2527// CODEGEN : file ../vk_helper.py line #1042 2528 ss[0].str(""); 2529// CODEGEN : file ../vk_helper.py line #931 2530// CODEGEN : file ../vk_helper.py line #936 2531// CODEGEN : file ../vk_helper.py line #938 2532 stp_strs[1] = ""; 2533 stringstream index_ss; 2534 for (uint32_t i = 0; i < 2; i++) { 2535 index_ss.str(""); 2536 index_ss << i; 2537// CODEGEN : file ../vk_helper.py line #979 2538 ss[1] << "0x" << &pStruct->srcOffsets[i]; 2539 tmp_str = vk_print_vkoffset3d(&pStruct->srcOffsets[i], extra_indent); 2540// CODEGEN : file ../vk_helper.py line #983 2541 stp_strs[1] += " " + prefix + "srcOffsets[" + index_ss.str() + "] (addr)\n" + tmp_str; 2542// CODEGEN : file ../vk_helper.py line #999 2543 ss[1].str(""); 2544 } 2545// CODEGEN : file ../vk_helper.py line #1037 2546 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->dstSubresource, extra_indent); 2547 ss[2] << "0x" << &pStruct->dstSubresource; 2548 stp_strs[2] = " " + prefix + "dstSubresource (addr)\n" + tmp_str; 2549// CODEGEN : file ../vk_helper.py line #1042 2550 ss[2].str(""); 2551// CODEGEN : file ../vk_helper.py line #931 2552// CODEGEN : file ../vk_helper.py line #936 2553// CODEGEN : file ../vk_helper.py line #938 2554 stp_strs[3] = ""; 2555 for (uint32_t i = 0; i < 2; i++) { 2556 index_ss.str(""); 2557 index_ss << i; 2558// CODEGEN : file ../vk_helper.py line #979 2559 ss[3] << "0x" << &pStruct->dstOffsets[i]; 2560 tmp_str = vk_print_vkoffset3d(&pStruct->dstOffsets[i], extra_indent); 2561// CODEGEN : file ../vk_helper.py line #983 2562 stp_strs[3] += " " + prefix + "dstOffsets[" + index_ss.str() + "] (addr)\n" + tmp_str; 2563// CODEGEN : file ../vk_helper.py line #999 2564 ss[3].str(""); 2565 } 2566// CODEGEN : file ../vk_helper.py line #1054 2567 ss[0].str("addr"); 2568// CODEGEN : file ../vk_helper.py line #1054 2569 ss[1].str("addr"); 2570// CODEGEN : file ../vk_helper.py line #1054 2571 ss[2].str("addr"); 2572// CODEGEN : file ../vk_helper.py line #1054 2573 ss[3].str("addr"); 2574// CODEGEN : file ../vk_helper.py line #1113 2575 final_str = prefix + "srcSubresource = " + ss[0].str() + "\n" + prefix + "srcOffsets = " + ss[1].str() + "\n" + prefix + "dstSubresource = " + ss[2].str() + "\n" + prefix + "dstOffsets = " + ss[3].str() + "\n" + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 2576 return final_str; 2577} 2578// CODEGEN : file ../vk_helper.py line #906 2579std::string vk_print_vkimagecopy(const VkImageCopy* pStruct, const std::string prefix) 2580{ 2581// CODEGEN : file ../vk_helper.py line #912 2582 using namespace StreamControl; 2583 using namespace std; 2584 string final_str; 2585 string tmp_str; 2586 string extra_indent = " " + prefix; 2587 stringstream ss[5]; 2588 string stp_strs[5]; 2589// CODEGEN : file ../vk_helper.py line #1037 2590 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->srcSubresource, extra_indent); 2591 ss[0] << "0x" << &pStruct->srcSubresource; 2592 stp_strs[0] = " " + prefix + "srcSubresource (addr)\n" + tmp_str; 2593// CODEGEN : file ../vk_helper.py line #1042 2594 ss[0].str(""); 2595// CODEGEN : file ../vk_helper.py line #1037 2596 tmp_str = vk_print_vkoffset3d(&pStruct->srcOffset, extra_indent); 2597 ss[1] << "0x" << &pStruct->srcOffset; 2598 stp_strs[1] = " " + prefix + "srcOffset (addr)\n" + tmp_str; 2599// CODEGEN : file ../vk_helper.py line #1042 2600 ss[1].str(""); 2601// CODEGEN : file ../vk_helper.py line #1037 2602 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->dstSubresource, extra_indent); 2603 ss[2] << "0x" << &pStruct->dstSubresource; 2604 stp_strs[2] = " " + prefix + "dstSubresource (addr)\n" + tmp_str; 2605// CODEGEN : file ../vk_helper.py line #1042 2606 ss[2].str(""); 2607// CODEGEN : file ../vk_helper.py line #1037 2608 tmp_str = vk_print_vkoffset3d(&pStruct->dstOffset, extra_indent); 2609 ss[3] << "0x" << &pStruct->dstOffset; 2610 stp_strs[3] = " " + prefix + "dstOffset (addr)\n" + tmp_str; 2611// CODEGEN : file ../vk_helper.py line #1042 2612 ss[3].str(""); 2613// CODEGEN : file ../vk_helper.py line #1037 2614 tmp_str = vk_print_vkextent3d(&pStruct->extent, extra_indent); 2615 ss[4] << "0x" << &pStruct->extent; 2616 stp_strs[4] = " " + prefix + "extent (addr)\n" + tmp_str; 2617// CODEGEN : file ../vk_helper.py line #1042 2618 ss[4].str(""); 2619// CODEGEN : file ../vk_helper.py line #1054 2620 ss[0].str("addr"); 2621// CODEGEN : file ../vk_helper.py line #1054 2622 ss[1].str("addr"); 2623// CODEGEN : file ../vk_helper.py line #1054 2624 ss[2].str("addr"); 2625// CODEGEN : file ../vk_helper.py line #1054 2626 ss[3].str("addr"); 2627// CODEGEN : file ../vk_helper.py line #1054 2628 ss[4].str("addr"); 2629// CODEGEN : file ../vk_helper.py line #1113 2630 final_str = prefix + "srcSubresource = " + ss[0].str() + "\n" + prefix + "srcOffset = " + ss[1].str() + "\n" + prefix + "dstSubresource = " + ss[2].str() + "\n" + prefix + "dstOffset = " + ss[3].str() + "\n" + prefix + "extent = " + ss[4].str() + "\n" + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 2631 return final_str; 2632} 2633// CODEGEN : file ../vk_helper.py line #906 2634std::string vk_print_vkimagecreateinfo(const VkImageCreateInfo* pStruct, const std::string prefix) 2635{ 2636// CODEGEN : file ../vk_helper.py line #912 2637 using namespace StreamControl; 2638 using namespace std; 2639 string final_str; 2640 string tmp_str; 2641 string extra_indent = " " + prefix; 2642 stringstream ss[8]; 2643 string stp_strs[3]; 2644// CODEGEN : file ../vk_helper.py line #1011 2645 if (pStruct->pNext) { 2646// CODEGEN : file ../vk_helper.py line #1015 2647 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2648 ss[0] << "0x" << &pStruct->pNext; 2649// CODEGEN : file ../vk_helper.py line #1027 2650 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2651 ss[0].str(""); 2652 } 2653 else 2654 stp_strs[0] = ""; 2655// CODEGEN : file ../vk_helper.py line #1037 2656 tmp_str = vk_print_vkextent3d(&pStruct->extent, extra_indent); 2657 ss[1] << "0x" << &pStruct->extent; 2658 stp_strs[1] = " " + prefix + "extent (addr)\n" + tmp_str; 2659// CODEGEN : file ../vk_helper.py line #1042 2660 ss[1].str(""); 2661// CODEGEN : file ../vk_helper.py line #931 2662// CODEGEN : file ../vk_helper.py line #933 2663// CODEGEN : file ../vk_helper.py line #938 2664 stp_strs[2] = ""; 2665 stringstream index_ss; 2666 if (pStruct->sharingMode == VK_SHARING_MODE_CONCURRENT) { 2667 if (pStruct->pQueueFamilyIndices) { 2668 for (uint32_t i = 0; i < pStruct->queueFamilyIndexCount; i++) { 2669 index_ss.str(""); 2670 index_ss << i; 2671// CODEGEN : file ../vk_helper.py line #989 2672 ss[2] << "0x" << pStruct->pQueueFamilyIndices[i]; 2673 stp_strs[2] += " " + prefix + "pQueueFamilyIndices[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 2674// CODEGEN : file ../vk_helper.py line #999 2675 ss[2].str(""); 2676 } 2677 } 2678 } 2679// CODEGEN : file ../vk_helper.py line #1069 2680 if (StreamControl::writeAddress) 2681 ss[0] << "0x" << pStruct->pNext; 2682 else 2683 ss[0].str("address"); 2684// CODEGEN : file ../vk_helper.py line #1085 2685 ss[1] << "0x" << pStruct->flags; 2686// CODEGEN : file ../vk_helper.py line #1054 2687 ss[2].str("addr"); 2688// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2689 ss[3] << pStruct->mipLevels; 2690// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2691 ss[4] << pStruct->arrayLayers; 2692// CODEGEN : file ../vk_helper.py line #1085 2693 ss[5] << "0x" << pStruct->usage; 2694// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2695 ss[6] << pStruct->queueFamilyIndexCount; 2696// CODEGEN : file ../vk_helper.py line #1060 2697 ss[7] << "0x" << (void*)pStruct->pQueueFamilyIndices; 2698// CODEGEN : file ../vk_helper.py line #1113 2699 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "imageType = " + string_VkImageType(pStruct->imageType) + "\n" + prefix + "format = " + string_VkFormat(pStruct->format) + "\n" + prefix + "extent = " + ss[2].str() + "\n" + prefix + "mipLevels = " + ss[3].str() + "\n" + prefix + "arrayLayers = " + ss[4].str() + "\n" + prefix + "samples = " + string_VkSampleCountFlagBits(pStruct->samples) + "\n" + prefix + "tiling = " + string_VkImageTiling(pStruct->tiling) + "\n" + prefix + "usage = " + ss[5].str() + "\n" + prefix + "sharingMode = " + string_VkSharingMode(pStruct->sharingMode) + "\n" + prefix + "queueFamilyIndexCount = " + ss[6].str() + "\n" + prefix + "pQueueFamilyIndices = " + ss[7].str() + "\n" + prefix + "initialLayout = " + string_VkImageLayout(pStruct->initialLayout) + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 2700 return final_str; 2701} 2702// CODEGEN : file ../vk_helper.py line #906 2703std::string vk_print_vkimageformatproperties(const VkImageFormatProperties* pStruct, const std::string prefix) 2704{ 2705// CODEGEN : file ../vk_helper.py line #912 2706 using namespace StreamControl; 2707 using namespace std; 2708 string final_str; 2709 string tmp_str; 2710 string extra_indent = " " + prefix; 2711 stringstream ss[5]; 2712 string stp_strs[1]; 2713// CODEGEN : file ../vk_helper.py line #1037 2714 tmp_str = vk_print_vkextent3d(&pStruct->maxExtent, extra_indent); 2715 ss[0] << "0x" << &pStruct->maxExtent; 2716 stp_strs[0] = " " + prefix + "maxExtent (addr)\n" + tmp_str; 2717// CODEGEN : file ../vk_helper.py line #1042 2718 ss[0].str(""); 2719// CODEGEN : file ../vk_helper.py line #1054 2720 ss[0].str("addr"); 2721// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2722 ss[1] << pStruct->maxMipLevels; 2723// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2724 ss[2] << pStruct->maxArrayLayers; 2725// CODEGEN : file ../vk_helper.py line #1085 2726 ss[3] << "0x" << pStruct->sampleCounts; 2727// CODEGEN : file ../vk_helper.py line #1085 2728 ss[4] << "0x" << pStruct->maxResourceSize; 2729// CODEGEN : file ../vk_helper.py line #1113 2730 final_str = prefix + "maxExtent = " + ss[0].str() + "\n" + prefix + "maxMipLevels = " + ss[1].str() + "\n" + prefix + "maxArrayLayers = " + ss[2].str() + "\n" + prefix + "sampleCounts = " + ss[3].str() + "\n" + prefix + "maxResourceSize = " + ss[4].str() + "\n" + stp_strs[0]; 2731 return final_str; 2732} 2733// CODEGEN : file ../vk_helper.py line #906 2734std::string vk_print_vkimagememorybarrier(const VkImageMemoryBarrier* pStruct, const std::string prefix) 2735{ 2736// CODEGEN : file ../vk_helper.py line #912 2737 using namespace StreamControl; 2738 using namespace std; 2739 string final_str; 2740 string tmp_str; 2741 string extra_indent = " " + prefix; 2742 stringstream ss[7]; 2743 string stp_strs[2]; 2744// CODEGEN : file ../vk_helper.py line #1011 2745 if (pStruct->pNext) { 2746// CODEGEN : file ../vk_helper.py line #1015 2747 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2748 ss[0] << "0x" << &pStruct->pNext; 2749// CODEGEN : file ../vk_helper.py line #1027 2750 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2751 ss[0].str(""); 2752 } 2753 else 2754 stp_strs[0] = ""; 2755// CODEGEN : file ../vk_helper.py line #1037 2756 tmp_str = vk_print_vkimagesubresourcerange(&pStruct->subresourceRange, extra_indent); 2757 ss[1] << "0x" << &pStruct->subresourceRange; 2758 stp_strs[1] = " " + prefix + "subresourceRange (addr)\n" + tmp_str; 2759// CODEGEN : file ../vk_helper.py line #1042 2760 ss[1].str(""); 2761// CODEGEN : file ../vk_helper.py line #1069 2762 if (StreamControl::writeAddress) 2763 ss[0] << "0x" << pStruct->pNext; 2764 else 2765 ss[0].str("address"); 2766// CODEGEN : file ../vk_helper.py line #1085 2767 ss[1] << "0x" << pStruct->srcAccessMask; 2768// CODEGEN : file ../vk_helper.py line #1085 2769 ss[2] << "0x" << pStruct->dstAccessMask; 2770// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2771 ss[3] << pStruct->srcQueueFamilyIndex; 2772// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2773 ss[4] << pStruct->dstQueueFamilyIndex; 2774// CODEGEN : file ../vk_helper.py line #1085 2775 ss[5] << "0x" << pStruct->image; 2776// CODEGEN : file ../vk_helper.py line #1054 2777 ss[6].str("addr"); 2778// CODEGEN : file ../vk_helper.py line #1113 2779 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "srcAccessMask = " + ss[1].str() + "\n" + prefix + "dstAccessMask = " + ss[2].str() + "\n" + prefix + "oldLayout = " + string_VkImageLayout(pStruct->oldLayout) + "\n" + prefix + "newLayout = " + string_VkImageLayout(pStruct->newLayout) + "\n" + prefix + "srcQueueFamilyIndex = " + ss[3].str() + "\n" + prefix + "dstQueueFamilyIndex = " + ss[4].str() + "\n" + prefix + "image = " + ss[5].str() + "\n" + prefix + "subresourceRange = " + ss[6].str() + "\n" + stp_strs[1] + stp_strs[0]; 2780 return final_str; 2781} 2782// CODEGEN : file ../vk_helper.py line #906 2783std::string vk_print_vkimageresolve(const VkImageResolve* pStruct, const std::string prefix) 2784{ 2785// CODEGEN : file ../vk_helper.py line #912 2786 using namespace StreamControl; 2787 using namespace std; 2788 string final_str; 2789 string tmp_str; 2790 string extra_indent = " " + prefix; 2791 stringstream ss[5]; 2792 string stp_strs[5]; 2793// CODEGEN : file ../vk_helper.py line #1037 2794 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->srcSubresource, extra_indent); 2795 ss[0] << "0x" << &pStruct->srcSubresource; 2796 stp_strs[0] = " " + prefix + "srcSubresource (addr)\n" + tmp_str; 2797// CODEGEN : file ../vk_helper.py line #1042 2798 ss[0].str(""); 2799// CODEGEN : file ../vk_helper.py line #1037 2800 tmp_str = vk_print_vkoffset3d(&pStruct->srcOffset, extra_indent); 2801 ss[1] << "0x" << &pStruct->srcOffset; 2802 stp_strs[1] = " " + prefix + "srcOffset (addr)\n" + tmp_str; 2803// CODEGEN : file ../vk_helper.py line #1042 2804 ss[1].str(""); 2805// CODEGEN : file ../vk_helper.py line #1037 2806 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->dstSubresource, extra_indent); 2807 ss[2] << "0x" << &pStruct->dstSubresource; 2808 stp_strs[2] = " " + prefix + "dstSubresource (addr)\n" + tmp_str; 2809// CODEGEN : file ../vk_helper.py line #1042 2810 ss[2].str(""); 2811// CODEGEN : file ../vk_helper.py line #1037 2812 tmp_str = vk_print_vkoffset3d(&pStruct->dstOffset, extra_indent); 2813 ss[3] << "0x" << &pStruct->dstOffset; 2814 stp_strs[3] = " " + prefix + "dstOffset (addr)\n" + tmp_str; 2815// CODEGEN : file ../vk_helper.py line #1042 2816 ss[3].str(""); 2817// CODEGEN : file ../vk_helper.py line #1037 2818 tmp_str = vk_print_vkextent3d(&pStruct->extent, extra_indent); 2819 ss[4] << "0x" << &pStruct->extent; 2820 stp_strs[4] = " " + prefix + "extent (addr)\n" + tmp_str; 2821// CODEGEN : file ../vk_helper.py line #1042 2822 ss[4].str(""); 2823// CODEGEN : file ../vk_helper.py line #1054 2824 ss[0].str("addr"); 2825// CODEGEN : file ../vk_helper.py line #1054 2826 ss[1].str("addr"); 2827// CODEGEN : file ../vk_helper.py line #1054 2828 ss[2].str("addr"); 2829// CODEGEN : file ../vk_helper.py line #1054 2830 ss[3].str("addr"); 2831// CODEGEN : file ../vk_helper.py line #1054 2832 ss[4].str("addr"); 2833// CODEGEN : file ../vk_helper.py line #1113 2834 final_str = prefix + "srcSubresource = " + ss[0].str() + "\n" + prefix + "srcOffset = " + ss[1].str() + "\n" + prefix + "dstSubresource = " + ss[2].str() + "\n" + prefix + "dstOffset = " + ss[3].str() + "\n" + prefix + "extent = " + ss[4].str() + "\n" + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 2835 return final_str; 2836} 2837// CODEGEN : file ../vk_helper.py line #906 2838std::string vk_print_vkimagesubresource(const VkImageSubresource* pStruct, const std::string prefix) 2839{ 2840// CODEGEN : file ../vk_helper.py line #912 2841 using namespace StreamControl; 2842 using namespace std; 2843 string final_str; 2844 string tmp_str; 2845 string extra_indent = " " + prefix; 2846 stringstream ss[3]; 2847// CODEGEN : file ../vk_helper.py line #1085 2848 ss[0] << "0x" << pStruct->aspectMask; 2849// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2850 ss[1] << pStruct->mipLevel; 2851// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2852 ss[2] << pStruct->arrayLayer; 2853// CODEGEN : file ../vk_helper.py line #1113 2854 final_str = prefix + "aspectMask = " + ss[0].str() + "\n" + prefix + "mipLevel = " + ss[1].str() + "\n" + prefix + "arrayLayer = " + ss[2].str() + "\n"; 2855 return final_str; 2856} 2857// CODEGEN : file ../vk_helper.py line #906 2858std::string vk_print_vkimagesubresourcelayers(const VkImageSubresourceLayers* pStruct, const std::string prefix) 2859{ 2860// CODEGEN : file ../vk_helper.py line #912 2861 using namespace StreamControl; 2862 using namespace std; 2863 string final_str; 2864 string tmp_str; 2865 string extra_indent = " " + prefix; 2866 stringstream ss[4]; 2867// CODEGEN : file ../vk_helper.py line #1085 2868 ss[0] << "0x" << pStruct->aspectMask; 2869// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2870 ss[1] << pStruct->mipLevel; 2871// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2872 ss[2] << pStruct->baseArrayLayer; 2873// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2874 ss[3] << pStruct->layerCount; 2875// CODEGEN : file ../vk_helper.py line #1113 2876 final_str = prefix + "aspectMask = " + ss[0].str() + "\n" + prefix + "mipLevel = " + ss[1].str() + "\n" + prefix + "baseArrayLayer = " + ss[2].str() + "\n" + prefix + "layerCount = " + ss[3].str() + "\n"; 2877 return final_str; 2878} 2879// CODEGEN : file ../vk_helper.py line #906 2880std::string vk_print_vkimagesubresourcerange(const VkImageSubresourceRange* pStruct, const std::string prefix) 2881{ 2882// CODEGEN : file ../vk_helper.py line #912 2883 using namespace StreamControl; 2884 using namespace std; 2885 string final_str; 2886 string tmp_str; 2887 string extra_indent = " " + prefix; 2888 stringstream ss[5]; 2889// CODEGEN : file ../vk_helper.py line #1085 2890 ss[0] << "0x" << pStruct->aspectMask; 2891// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2892 ss[1] << pStruct->baseMipLevel; 2893// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2894 ss[2] << pStruct->levelCount; 2895// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2896 ss[3] << pStruct->baseArrayLayer; 2897// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 2898 ss[4] << pStruct->layerCount; 2899// CODEGEN : file ../vk_helper.py line #1113 2900 final_str = prefix + "aspectMask = " + ss[0].str() + "\n" + prefix + "baseMipLevel = " + ss[1].str() + "\n" + prefix + "levelCount = " + ss[2].str() + "\n" + prefix + "baseArrayLayer = " + ss[3].str() + "\n" + prefix + "layerCount = " + ss[4].str() + "\n"; 2901 return final_str; 2902} 2903// CODEGEN : file ../vk_helper.py line #906 2904std::string vk_print_vkimageviewcreateinfo(const VkImageViewCreateInfo* pStruct, const std::string prefix) 2905{ 2906// CODEGEN : file ../vk_helper.py line #912 2907 using namespace StreamControl; 2908 using namespace std; 2909 string final_str; 2910 string tmp_str; 2911 string extra_indent = " " + prefix; 2912 stringstream ss[5]; 2913 string stp_strs[3]; 2914// CODEGEN : file ../vk_helper.py line #1011 2915 if (pStruct->pNext) { 2916// CODEGEN : file ../vk_helper.py line #1015 2917 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2918 ss[0] << "0x" << &pStruct->pNext; 2919// CODEGEN : file ../vk_helper.py line #1027 2920 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2921 ss[0].str(""); 2922 } 2923 else 2924 stp_strs[0] = ""; 2925// CODEGEN : file ../vk_helper.py line #1037 2926 tmp_str = vk_print_vkcomponentmapping(&pStruct->components, extra_indent); 2927 ss[1] << "0x" << &pStruct->components; 2928 stp_strs[1] = " " + prefix + "components (addr)\n" + tmp_str; 2929// CODEGEN : file ../vk_helper.py line #1042 2930 ss[1].str(""); 2931// CODEGEN : file ../vk_helper.py line #1037 2932 tmp_str = vk_print_vkimagesubresourcerange(&pStruct->subresourceRange, extra_indent); 2933 ss[2] << "0x" << &pStruct->subresourceRange; 2934 stp_strs[2] = " " + prefix + "subresourceRange (addr)\n" + tmp_str; 2935// CODEGEN : file ../vk_helper.py line #1042 2936 ss[2].str(""); 2937// CODEGEN : file ../vk_helper.py line #1069 2938 if (StreamControl::writeAddress) 2939 ss[0] << "0x" << pStruct->pNext; 2940 else 2941 ss[0].str("address"); 2942// CODEGEN : file ../vk_helper.py line #1085 2943 ss[1] << "0x" << pStruct->flags; 2944// CODEGEN : file ../vk_helper.py line #1085 2945 ss[2] << "0x" << pStruct->image; 2946// CODEGEN : file ../vk_helper.py line #1054 2947 ss[3].str("addr"); 2948// CODEGEN : file ../vk_helper.py line #1054 2949 ss[4].str("addr"); 2950// CODEGEN : file ../vk_helper.py line #1113 2951 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "image = " + ss[2].str() + "\n" + prefix + "viewType = " + string_VkImageViewType(pStruct->viewType) + "\n" + prefix + "format = " + string_VkFormat(pStruct->format) + "\n" + prefix + "components = " + ss[3].str() + "\n" + prefix + "subresourceRange = " + ss[4].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 2952 return final_str; 2953} 2954// CODEGEN : file ../vk_helper.py line #906 2955std::string vk_print_vkinstancecreateinfo(const VkInstanceCreateInfo* pStruct, const std::string prefix) 2956{ 2957// CODEGEN : file ../vk_helper.py line #912 2958 using namespace StreamControl; 2959 using namespace std; 2960 string final_str; 2961 string tmp_str; 2962 string extra_indent = " " + prefix; 2963 stringstream ss[7]; 2964 string stp_strs[4]; 2965// CODEGEN : file ../vk_helper.py line #1011 2966 if (pStruct->pNext) { 2967// CODEGEN : file ../vk_helper.py line #1015 2968 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2969 ss[0] << "0x" << &pStruct->pNext; 2970// CODEGEN : file ../vk_helper.py line #1027 2971 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2972 ss[0].str(""); 2973 } 2974 else 2975 stp_strs[0] = ""; 2976// CODEGEN : file ../vk_helper.py line #1011 2977 if (pStruct->pApplicationInfo) { 2978// CODEGEN : file ../vk_helper.py line #1023 2979 tmp_str = vk_print_vkapplicationinfo(pStruct->pApplicationInfo, extra_indent); 2980 ss[1] << "0x" << &pStruct->pApplicationInfo; 2981// CODEGEN : file ../vk_helper.py line #1027 2982 stp_strs[1] = " " + prefix + "pApplicationInfo (addr)\n" + tmp_str; 2983 ss[1].str(""); 2984 } 2985 else 2986 stp_strs[1] = ""; 2987// CODEGEN : file ../vk_helper.py line #931 2988// CODEGEN : file ../vk_helper.py line #933 2989// CODEGEN : file ../vk_helper.py line #938 2990 stp_strs[2] = ""; 2991 stringstream index_ss; 2992 if (pStruct->ppEnabledLayerNames) { 2993 for (uint32_t i = 0; i < pStruct->enabledLayerCount; i++) { 2994 index_ss.str(""); 2995 index_ss << i; 2996// CODEGEN : file ../vk_helper.py line #989 2997 ss[2] << "0x" << pStruct->ppEnabledLayerNames[i]; 2998 stp_strs[2] += " " + prefix + "ppEnabledLayerNames[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 2999// CODEGEN : file ../vk_helper.py line #999 3000 ss[2].str(""); 3001 } 3002 } 3003// CODEGEN : file ../vk_helper.py line #931 3004// CODEGEN : file ../vk_helper.py line #933 3005// CODEGEN : file ../vk_helper.py line #938 3006 stp_strs[3] = ""; 3007 if (pStruct->ppEnabledExtensionNames) { 3008 for (uint32_t i = 0; i < pStruct->enabledExtensionCount; i++) { 3009 index_ss.str(""); 3010 index_ss << i; 3011// CODEGEN : file ../vk_helper.py line #989 3012 ss[3] << "0x" << pStruct->ppEnabledExtensionNames[i]; 3013 stp_strs[3] += " " + prefix + "ppEnabledExtensionNames[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 3014// CODEGEN : file ../vk_helper.py line #999 3015 ss[3].str(""); 3016 } 3017 } 3018// CODEGEN : file ../vk_helper.py line #1069 3019 if (StreamControl::writeAddress) 3020 ss[0] << "0x" << pStruct->pNext; 3021 else 3022 ss[0].str("address"); 3023// CODEGEN : file ../vk_helper.py line #1085 3024 ss[1] << "0x" << pStruct->flags; 3025// CODEGEN : file ../vk_helper.py line #1085 3026 ss[2] << "0x" << pStruct->pApplicationInfo; 3027// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3028 ss[3] << pStruct->enabledLayerCount; 3029// CODEGEN : file ../vk_helper.py line #1060 3030 ss[4] << "0x" << (void*)pStruct->ppEnabledLayerNames; 3031// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3032 ss[5] << pStruct->enabledExtensionCount; 3033// CODEGEN : file ../vk_helper.py line #1060 3034 ss[6] << "0x" << (void*)pStruct->ppEnabledExtensionNames; 3035// CODEGEN : file ../vk_helper.py line #1113 3036 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "pApplicationInfo = " + ss[2].str() + "\n" + prefix + "enabledLayerCount = " + ss[3].str() + "\n" + prefix + "ppEnabledLayerNames = " + ss[4].str() + "\n" + prefix + "enabledExtensionCount = " + ss[5].str() + "\n" + prefix + "ppEnabledExtensionNames = " + ss[6].str() + "\n" + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3037 return final_str; 3038} 3039// CODEGEN : file ../vk_helper.py line #906 3040std::string vk_print_vklayerproperties(const VkLayerProperties* pStruct, const std::string prefix) 3041{ 3042// CODEGEN : file ../vk_helper.py line #912 3043 using namespace StreamControl; 3044 using namespace std; 3045 string final_str; 3046 string tmp_str; 3047 string extra_indent = " " + prefix; 3048 stringstream ss[4]; 3049 string stp_strs[2]; 3050// CODEGEN : file ../vk_helper.py line #931 3051// CODEGEN : file ../vk_helper.py line #936 3052// CODEGEN : file ../vk_helper.py line #938 3053 stp_strs[0] = ""; 3054 stringstream index_ss; 3055 for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) { 3056 index_ss.str(""); 3057 index_ss << i; 3058// CODEGEN : file ../vk_helper.py line #989 3059 ss[0] << pStruct->layerName[i]; 3060 stp_strs[0] += " " + prefix + "layerName[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 3061// CODEGEN : file ../vk_helper.py line #999 3062 ss[0].str(""); 3063 } 3064// CODEGEN : file ../vk_helper.py line #931 3065// CODEGEN : file ../vk_helper.py line #936 3066// CODEGEN : file ../vk_helper.py line #938 3067 stp_strs[1] = ""; 3068 for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { 3069 index_ss.str(""); 3070 index_ss << i; 3071// CODEGEN : file ../vk_helper.py line #989 3072 ss[1] << pStruct->description[i]; 3073 stp_strs[1] += " " + prefix + "description[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 3074// CODEGEN : file ../vk_helper.py line #999 3075 ss[1].str(""); 3076 } 3077// CODEGEN : file ../vk_helper.py line #1060 3078 ss[0] << "0x" << (void*)pStruct->layerName; 3079// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3080 ss[1] << pStruct->specVersion; 3081// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3082 ss[2] << pStruct->implementationVersion; 3083// CODEGEN : file ../vk_helper.py line #1060 3084 ss[3] << "0x" << (void*)pStruct->description; 3085// CODEGEN : file ../vk_helper.py line #1113 3086 final_str = prefix + "layerName = " + ss[0].str() + "\n" + prefix + "specVersion = " + ss[1].str() + "\n" + prefix + "implementationVersion = " + ss[2].str() + "\n" + prefix + "description = " + ss[3].str() + "\n" + stp_strs[1] + stp_strs[0]; 3087 return final_str; 3088} 3089// CODEGEN : file ../vk_helper.py line #906 3090std::string vk_print_vkmappedmemoryrange(const VkMappedMemoryRange* pStruct, const std::string prefix) 3091{ 3092// CODEGEN : file ../vk_helper.py line #912 3093 using namespace StreamControl; 3094 using namespace std; 3095 string final_str; 3096 string tmp_str; 3097 string extra_indent = " " + prefix; 3098 stringstream ss[4]; 3099 string stp_strs[1]; 3100// CODEGEN : file ../vk_helper.py line #1011 3101 if (pStruct->pNext) { 3102// CODEGEN : file ../vk_helper.py line #1015 3103 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3104 ss[0] << "0x" << &pStruct->pNext; 3105// CODEGEN : file ../vk_helper.py line #1027 3106 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3107 ss[0].str(""); 3108 } 3109 else 3110 stp_strs[0] = ""; 3111// CODEGEN : file ../vk_helper.py line #1069 3112 if (StreamControl::writeAddress) 3113 ss[0] << "0x" << pStruct->pNext; 3114 else 3115 ss[0].str("address"); 3116// CODEGEN : file ../vk_helper.py line #1085 3117 ss[1] << "0x" << pStruct->memory; 3118// CODEGEN : file ../vk_helper.py line #1085 3119 ss[2] << "0x" << pStruct->offset; 3120// CODEGEN : file ../vk_helper.py line #1085 3121 ss[3] << "0x" << pStruct->size; 3122// CODEGEN : file ../vk_helper.py line #1113 3123 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "memory = " + ss[1].str() + "\n" + prefix + "offset = " + ss[2].str() + "\n" + prefix + "size = " + ss[3].str() + "\n" + stp_strs[0]; 3124 return final_str; 3125} 3126// CODEGEN : file ../vk_helper.py line #906 3127std::string vk_print_vkmemoryallocateinfo(const VkMemoryAllocateInfo* pStruct, const std::string prefix) 3128{ 3129// CODEGEN : file ../vk_helper.py line #912 3130 using namespace StreamControl; 3131 using namespace std; 3132 string final_str; 3133 string tmp_str; 3134 string extra_indent = " " + prefix; 3135 stringstream ss[3]; 3136 string stp_strs[1]; 3137// CODEGEN : file ../vk_helper.py line #1011 3138 if (pStruct->pNext) { 3139// CODEGEN : file ../vk_helper.py line #1015 3140 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3141 ss[0] << "0x" << &pStruct->pNext; 3142// CODEGEN : file ../vk_helper.py line #1027 3143 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3144 ss[0].str(""); 3145 } 3146 else 3147 stp_strs[0] = ""; 3148// CODEGEN : file ../vk_helper.py line #1069 3149 if (StreamControl::writeAddress) 3150 ss[0] << "0x" << pStruct->pNext; 3151 else 3152 ss[0].str("address"); 3153// CODEGEN : file ../vk_helper.py line #1085 3154 ss[1] << "0x" << pStruct->allocationSize; 3155// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3156 ss[2] << pStruct->memoryTypeIndex; 3157// CODEGEN : file ../vk_helper.py line #1113 3158 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "allocationSize = " + ss[1].str() + "\n" + prefix + "memoryTypeIndex = " + ss[2].str() + "\n" + stp_strs[0]; 3159 return final_str; 3160} 3161// CODEGEN : file ../vk_helper.py line #906 3162std::string vk_print_vkmemorybarrier(const VkMemoryBarrier* pStruct, const std::string prefix) 3163{ 3164// CODEGEN : file ../vk_helper.py line #912 3165 using namespace StreamControl; 3166 using namespace std; 3167 string final_str; 3168 string tmp_str; 3169 string extra_indent = " " + prefix; 3170 stringstream ss[3]; 3171 string stp_strs[1]; 3172// CODEGEN : file ../vk_helper.py line #1011 3173 if (pStruct->pNext) { 3174// CODEGEN : file ../vk_helper.py line #1015 3175 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3176 ss[0] << "0x" << &pStruct->pNext; 3177// CODEGEN : file ../vk_helper.py line #1027 3178 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3179 ss[0].str(""); 3180 } 3181 else 3182 stp_strs[0] = ""; 3183// CODEGEN : file ../vk_helper.py line #1069 3184 if (StreamControl::writeAddress) 3185 ss[0] << "0x" << pStruct->pNext; 3186 else 3187 ss[0].str("address"); 3188// CODEGEN : file ../vk_helper.py line #1085 3189 ss[1] << "0x" << pStruct->srcAccessMask; 3190// CODEGEN : file ../vk_helper.py line #1085 3191 ss[2] << "0x" << pStruct->dstAccessMask; 3192// CODEGEN : file ../vk_helper.py line #1113 3193 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "srcAccessMask = " + ss[1].str() + "\n" + prefix + "dstAccessMask = " + ss[2].str() + "\n" + stp_strs[0]; 3194 return final_str; 3195} 3196// CODEGEN : file ../vk_helper.py line #906 3197std::string vk_print_vkmemoryheap(const VkMemoryHeap* pStruct, const std::string prefix) 3198{ 3199// CODEGEN : file ../vk_helper.py line #912 3200 using namespace StreamControl; 3201 using namespace std; 3202 string final_str; 3203 string tmp_str; 3204 string extra_indent = " " + prefix; 3205 stringstream ss[2]; 3206// CODEGEN : file ../vk_helper.py line #1085 3207 ss[0] << "0x" << pStruct->size; 3208// CODEGEN : file ../vk_helper.py line #1085 3209 ss[1] << "0x" << pStruct->flags; 3210// CODEGEN : file ../vk_helper.py line #1113 3211 final_str = prefix + "size = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n"; 3212 return final_str; 3213} 3214// CODEGEN : file ../vk_helper.py line #906 3215std::string vk_print_vkmemoryrequirements(const VkMemoryRequirements* pStruct, const std::string prefix) 3216{ 3217// CODEGEN : file ../vk_helper.py line #912 3218 using namespace StreamControl; 3219 using namespace std; 3220 string final_str; 3221 string tmp_str; 3222 string extra_indent = " " + prefix; 3223 stringstream ss[3]; 3224// CODEGEN : file ../vk_helper.py line #1085 3225 ss[0] << "0x" << pStruct->size; 3226// CODEGEN : file ../vk_helper.py line #1085 3227 ss[1] << "0x" << pStruct->alignment; 3228// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3229 ss[2] << "0x" << pStruct->memoryTypeBits; 3230// CODEGEN : file ../vk_helper.py line #1113 3231 final_str = prefix + "size = " + ss[0].str() + "\n" + prefix + "alignment = " + ss[1].str() + "\n" + prefix + "memoryTypeBits = " + ss[2].str() + "\n"; 3232 return final_str; 3233} 3234// CODEGEN : file ../vk_helper.py line #906 3235std::string vk_print_vkmemorytype(const VkMemoryType* pStruct, const std::string prefix) 3236{ 3237// CODEGEN : file ../vk_helper.py line #912 3238 using namespace StreamControl; 3239 using namespace std; 3240 string final_str; 3241 string tmp_str; 3242 string extra_indent = " " + prefix; 3243 stringstream ss[2]; 3244// CODEGEN : file ../vk_helper.py line #1085 3245 ss[0] << "0x" << pStruct->propertyFlags; 3246// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3247 ss[1] << pStruct->heapIndex; 3248// CODEGEN : file ../vk_helper.py line #1113 3249 final_str = prefix + "propertyFlags = " + ss[0].str() + "\n" + prefix + "heapIndex = " + ss[1].str() + "\n"; 3250 return final_str; 3251} 3252// CODEGEN : file ../vk_helper.py line #906 3253#ifdef VK_USE_PLATFORM_MIR_KHR 3254std::string vk_print_vkmirsurfacecreateinfokhr(const VkMirSurfaceCreateInfoKHR* pStruct, const std::string prefix) 3255{ 3256// CODEGEN : file ../vk_helper.py line #912 3257 using namespace StreamControl; 3258 using namespace std; 3259 string final_str; 3260 string tmp_str; 3261 string extra_indent = " " + prefix; 3262 stringstream ss[4]; 3263 string stp_strs[1]; 3264// CODEGEN : file ../vk_helper.py line #1011 3265 if (pStruct->pNext) { 3266// CODEGEN : file ../vk_helper.py line #1015 3267 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3268 ss[0] << "0x" << &pStruct->pNext; 3269// CODEGEN : file ../vk_helper.py line #1027 3270 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3271 ss[0].str(""); 3272 } 3273 else 3274 stp_strs[0] = ""; 3275// CODEGEN : file ../vk_helper.py line #1069 3276 if (StreamControl::writeAddress) 3277 ss[0] << "0x" << pStruct->pNext; 3278 else 3279 ss[0].str("address"); 3280// CODEGEN : file ../vk_helper.py line #1085 3281 ss[1] << "0x" << pStruct->flags; 3282// CODEGEN : file ../vk_helper.py line #1085 3283 ss[2] << "0x" << pStruct->connection; 3284// CODEGEN : file ../vk_helper.py line #1085 3285 ss[3] << "0x" << pStruct->mirSurface; 3286// CODEGEN : file ../vk_helper.py line #1113 3287 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "connection = " + ss[2].str() + "\n" + prefix + "mirSurface = " + ss[3].str() + "\n" + stp_strs[0]; 3288 return final_str; 3289} 3290#endif //VK_USE_PLATFORM_MIR_KHR 3291// CODEGEN : file ../vk_helper.py line #906 3292std::string vk_print_vkoffset2d(const VkOffset2D* pStruct, const std::string prefix) 3293{ 3294// CODEGEN : file ../vk_helper.py line #912 3295 using namespace StreamControl; 3296 using namespace std; 3297 string final_str; 3298 string tmp_str; 3299 string extra_indent = " " + prefix; 3300 stringstream ss[2]; 3301// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3302 ss[0] << pStruct->x; 3303// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3304 ss[1] << pStruct->y; 3305// CODEGEN : file ../vk_helper.py line #1113 3306 final_str = prefix + "x = " + ss[0].str() + "\n" + prefix + "y = " + ss[1].str() + "\n"; 3307 return final_str; 3308} 3309// CODEGEN : file ../vk_helper.py line #906 3310std::string vk_print_vkoffset3d(const VkOffset3D* pStruct, const std::string prefix) 3311{ 3312// CODEGEN : file ../vk_helper.py line #912 3313 using namespace StreamControl; 3314 using namespace std; 3315 string final_str; 3316 string tmp_str; 3317 string extra_indent = " " + prefix; 3318 stringstream ss[3]; 3319// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3320 ss[0] << pStruct->x; 3321// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3322 ss[1] << pStruct->y; 3323// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3324 ss[2] << pStruct->z; 3325// CODEGEN : file ../vk_helper.py line #1113 3326 final_str = prefix + "x = " + ss[0].str() + "\n" + prefix + "y = " + ss[1].str() + "\n" + prefix + "z = " + ss[2].str() + "\n"; 3327 return final_str; 3328} 3329// CODEGEN : file ../vk_helper.py line #906 3330std::string vk_print_vkphysicaldevicefeatures(const VkPhysicalDeviceFeatures* pStruct, const std::string prefix) 3331{ 3332// CODEGEN : file ../vk_helper.py line #912 3333 using namespace StreamControl; 3334 using namespace std; 3335 string final_str; 3336 string tmp_str; 3337 string extra_indent = " " + prefix; 3338 stringstream ss[55]; 3339// CODEGEN : file ../vk_helper.py line #1063 3340 ss[0].str(pStruct->robustBufferAccess ? "TRUE" : "FALSE"); 3341// CODEGEN : file ../vk_helper.py line #1063 3342 ss[1].str(pStruct->fullDrawIndexUint32 ? "TRUE" : "FALSE"); 3343// CODEGEN : file ../vk_helper.py line #1063 3344 ss[2].str(pStruct->imageCubeArray ? "TRUE" : "FALSE"); 3345// CODEGEN : file ../vk_helper.py line #1063 3346 ss[3].str(pStruct->independentBlend ? "TRUE" : "FALSE"); 3347// CODEGEN : file ../vk_helper.py line #1063 3348 ss[4].str(pStruct->geometryShader ? "TRUE" : "FALSE"); 3349// CODEGEN : file ../vk_helper.py line #1063 3350 ss[5].str(pStruct->tessellationShader ? "TRUE" : "FALSE"); 3351// CODEGEN : file ../vk_helper.py line #1063 3352 ss[6].str(pStruct->sampleRateShading ? "TRUE" : "FALSE"); 3353// CODEGEN : file ../vk_helper.py line #1063 3354 ss[7].str(pStruct->dualSrcBlend ? "TRUE" : "FALSE"); 3355// CODEGEN : file ../vk_helper.py line #1063 3356 ss[8].str(pStruct->logicOp ? "TRUE" : "FALSE"); 3357// CODEGEN : file ../vk_helper.py line #1063 3358 ss[9].str(pStruct->multiDrawIndirect ? "TRUE" : "FALSE"); 3359// CODEGEN : file ../vk_helper.py line #1063 3360 ss[10].str(pStruct->drawIndirectFirstInstance ? "TRUE" : "FALSE"); 3361// CODEGEN : file ../vk_helper.py line #1063 3362 ss[11].str(pStruct->depthClamp ? "TRUE" : "FALSE"); 3363// CODEGEN : file ../vk_helper.py line #1063 3364 ss[12].str(pStruct->depthBiasClamp ? "TRUE" : "FALSE"); 3365// CODEGEN : file ../vk_helper.py line #1063 3366 ss[13].str(pStruct->fillModeNonSolid ? "TRUE" : "FALSE"); 3367// CODEGEN : file ../vk_helper.py line #1063 3368 ss[14].str(pStruct->depthBounds ? "TRUE" : "FALSE"); 3369// CODEGEN : file ../vk_helper.py line #1063 3370 ss[15].str(pStruct->wideLines ? "TRUE" : "FALSE"); 3371// CODEGEN : file ../vk_helper.py line #1063 3372 ss[16].str(pStruct->largePoints ? "TRUE" : "FALSE"); 3373// CODEGEN : file ../vk_helper.py line #1063 3374 ss[17].str(pStruct->alphaToOne ? "TRUE" : "FALSE"); 3375// CODEGEN : file ../vk_helper.py line #1063 3376 ss[18].str(pStruct->multiViewport ? "TRUE" : "FALSE"); 3377// CODEGEN : file ../vk_helper.py line #1063 3378 ss[19].str(pStruct->samplerAnisotropy ? "TRUE" : "FALSE"); 3379// CODEGEN : file ../vk_helper.py line #1063 3380 ss[20].str(pStruct->textureCompressionETC2 ? "TRUE" : "FALSE"); 3381// CODEGEN : file ../vk_helper.py line #1063 3382 ss[21].str(pStruct->textureCompressionASTC_LDR ? "TRUE" : "FALSE"); 3383// CODEGEN : file ../vk_helper.py line #1063 3384 ss[22].str(pStruct->textureCompressionBC ? "TRUE" : "FALSE"); 3385// CODEGEN : file ../vk_helper.py line #1063 3386 ss[23].str(pStruct->occlusionQueryPrecise ? "TRUE" : "FALSE"); 3387// CODEGEN : file ../vk_helper.py line #1063 3388 ss[24].str(pStruct->pipelineStatisticsQuery ? "TRUE" : "FALSE"); 3389// CODEGEN : file ../vk_helper.py line #1063 3390 ss[25].str(pStruct->vertexPipelineStoresAndAtomics ? "TRUE" : "FALSE"); 3391// CODEGEN : file ../vk_helper.py line #1063 3392 ss[26].str(pStruct->fragmentStoresAndAtomics ? "TRUE" : "FALSE"); 3393// CODEGEN : file ../vk_helper.py line #1063 3394 ss[27].str(pStruct->shaderTessellationAndGeometryPointSize ? "TRUE" : "FALSE"); 3395// CODEGEN : file ../vk_helper.py line #1063 3396 ss[28].str(pStruct->shaderImageGatherExtended ? "TRUE" : "FALSE"); 3397// CODEGEN : file ../vk_helper.py line #1063 3398 ss[29].str(pStruct->shaderStorageImageExtendedFormats ? "TRUE" : "FALSE"); 3399// CODEGEN : file ../vk_helper.py line #1063 3400 ss[30].str(pStruct->shaderStorageImageMultisample ? "TRUE" : "FALSE"); 3401// CODEGEN : file ../vk_helper.py line #1063 3402 ss[31].str(pStruct->shaderStorageImageReadWithoutFormat ? "TRUE" : "FALSE"); 3403// CODEGEN : file ../vk_helper.py line #1063 3404 ss[32].str(pStruct->shaderStorageImageWriteWithoutFormat ? "TRUE" : "FALSE"); 3405// CODEGEN : file ../vk_helper.py line #1063 3406 ss[33].str(pStruct->shaderUniformBufferArrayDynamicIndexing ? "TRUE" : "FALSE"); 3407// CODEGEN : file ../vk_helper.py line #1063 3408 ss[34].str(pStruct->shaderSampledImageArrayDynamicIndexing ? "TRUE" : "FALSE"); 3409// CODEGEN : file ../vk_helper.py line #1063 3410 ss[35].str(pStruct->shaderStorageBufferArrayDynamicIndexing ? "TRUE" : "FALSE"); 3411// CODEGEN : file ../vk_helper.py line #1063 3412 ss[36].str(pStruct->shaderStorageImageArrayDynamicIndexing ? "TRUE" : "FALSE"); 3413// CODEGEN : file ../vk_helper.py line #1063 3414 ss[37].str(pStruct->shaderClipDistance ? "TRUE" : "FALSE"); 3415// CODEGEN : file ../vk_helper.py line #1063 3416 ss[38].str(pStruct->shaderCullDistance ? "TRUE" : "FALSE"); 3417// CODEGEN : file ../vk_helper.py line #1063 3418 ss[39].str(pStruct->shaderFloat64 ? "TRUE" : "FALSE"); 3419// CODEGEN : file ../vk_helper.py line #1063 3420 ss[40].str(pStruct->shaderInt64 ? "TRUE" : "FALSE"); 3421// CODEGEN : file ../vk_helper.py line #1063 3422 ss[41].str(pStruct->shaderInt16 ? "TRUE" : "FALSE"); 3423// CODEGEN : file ../vk_helper.py line #1063 3424 ss[42].str(pStruct->shaderResourceResidency ? "TRUE" : "FALSE"); 3425// CODEGEN : file ../vk_helper.py line #1063 3426 ss[43].str(pStruct->shaderResourceMinLod ? "TRUE" : "FALSE"); 3427// CODEGEN : file ../vk_helper.py line #1063 3428 ss[44].str(pStruct->sparseBinding ? "TRUE" : "FALSE"); 3429// CODEGEN : file ../vk_helper.py line #1063 3430 ss[45].str(pStruct->sparseResidencyBuffer ? "TRUE" : "FALSE"); 3431// CODEGEN : file ../vk_helper.py line #1063 3432 ss[46].str(pStruct->sparseResidencyImage2D ? "TRUE" : "FALSE"); 3433// CODEGEN : file ../vk_helper.py line #1063 3434 ss[47].str(pStruct->sparseResidencyImage3D ? "TRUE" : "FALSE"); 3435// CODEGEN : file ../vk_helper.py line #1063 3436 ss[48].str(pStruct->sparseResidency2Samples ? "TRUE" : "FALSE"); 3437// CODEGEN : file ../vk_helper.py line #1063 3438 ss[49].str(pStruct->sparseResidency4Samples ? "TRUE" : "FALSE"); 3439// CODEGEN : file ../vk_helper.py line #1063 3440 ss[50].str(pStruct->sparseResidency8Samples ? "TRUE" : "FALSE"); 3441// CODEGEN : file ../vk_helper.py line #1063 3442 ss[51].str(pStruct->sparseResidency16Samples ? "TRUE" : "FALSE"); 3443// CODEGEN : file ../vk_helper.py line #1063 3444 ss[52].str(pStruct->sparseResidencyAliased ? "TRUE" : "FALSE"); 3445// CODEGEN : file ../vk_helper.py line #1063 3446 ss[53].str(pStruct->variableMultisampleRate ? "TRUE" : "FALSE"); 3447// CODEGEN : file ../vk_helper.py line #1063 3448 ss[54].str(pStruct->inheritedQueries ? "TRUE" : "FALSE"); 3449// CODEGEN : file ../vk_helper.py line #1113 3450 final_str = prefix + "robustBufferAccess = " + ss[0].str() + "\n" + prefix + "fullDrawIndexUint32 = " + ss[1].str() + "\n" + prefix + "imageCubeArray = " + ss[2].str() + "\n" + prefix + "independentBlend = " + ss[3].str() + "\n" + prefix + "geometryShader = " + ss[4].str() + "\n" + prefix + "tessellationShader = " + ss[5].str() + "\n" + prefix + "sampleRateShading = " + ss[6].str() + "\n" + prefix + "dualSrcBlend = " + ss[7].str() + "\n" + prefix + "logicOp = " + ss[8].str() + "\n" + prefix + "multiDrawIndirect = " + ss[9].str() + "\n" + prefix + "drawIndirectFirstInstance = " + ss[10].str() + "\n" + prefix + "depthClamp = " + ss[11].str() + "\n" + prefix + "depthBiasClamp = " + ss[12].str() + "\n" + prefix + "fillModeNonSolid = " + ss[13].str() + "\n" + prefix + "depthBounds = " + ss[14].str() + "\n" + prefix + "wideLines = " + ss[15].str() + "\n" + prefix + "largePoints = " + ss[16].str() + "\n" + prefix + "alphaToOne = " + ss[17].str() + "\n" + prefix + "multiViewport = " + ss[18].str() + "\n" + prefix + "samplerAnisotropy = " + ss[19].str() + "\n" + prefix + "textureCompressionETC2 = " + ss[20].str() + "\n" + prefix + "textureCompressionASTC_LDR = " + ss[21].str() + "\n" + prefix + "textureCompressionBC = " + ss[22].str() + "\n" + prefix + "occlusionQueryPrecise = " + ss[23].str() + "\n" + prefix + "pipelineStatisticsQuery = " + ss[24].str() + "\n" + prefix + "vertexPipelineStoresAndAtomics = " + ss[25].str() + "\n" + prefix + "fragmentStoresAndAtomics = " + ss[26].str() + "\n" + prefix + "shaderTessellationAndGeometryPointSize = " + ss[27].str() + "\n" + prefix + "shaderImageGatherExtended = " + ss[28].str() + "\n" + prefix + "shaderStorageImageExtendedFormats = " + ss[29].str() + "\n" + prefix + "shaderStorageImageMultisample = " + ss[30].str() + "\n" + prefix + "shaderStorageImageReadWithoutFormat = " + ss[31].str() + "\n" + prefix + "shaderStorageImageWriteWithoutFormat = " + ss[32].str() + "\n" + prefix + "shaderUniformBufferArrayDynamicIndexing = " + ss[33].str() + "\n" + prefix + "shaderSampledImageArrayDynamicIndexing = " + ss[34].str() + "\n" + prefix + "shaderStorageBufferArrayDynamicIndexing = " + ss[35].str() + "\n" + prefix + "shaderStorageImageArrayDynamicIndexing = " + ss[36].str() + "\n" + prefix + "shaderClipDistance = " + ss[37].str() + "\n" + prefix + "shaderCullDistance = " + ss[38].str() + "\n" + prefix + "shaderFloat64 = " + ss[39].str() + "\n" + prefix + "shaderInt64 = " + ss[40].str() + "\n" + prefix + "shaderInt16 = " + ss[41].str() + "\n" + prefix + "shaderResourceResidency = " + ss[42].str() + "\n" + prefix + "shaderResourceMinLod = " + ss[43].str() + "\n" + prefix + "sparseBinding = " + ss[44].str() + "\n" + prefix + "sparseResidencyBuffer = " + ss[45].str() + "\n" + prefix + "sparseResidencyImage2D = " + ss[46].str() + "\n" + prefix + "sparseResidencyImage3D = " + ss[47].str() + "\n" + prefix + "sparseResidency2Samples = " + ss[48].str() + "\n" + prefix + "sparseResidency4Samples = " + ss[49].str() + "\n" + prefix + "sparseResidency8Samples = " + ss[50].str() + "\n" + prefix + "sparseResidency16Samples = " + ss[51].str() + "\n" + prefix + "sparseResidencyAliased = " + ss[52].str() + "\n" + prefix + "variableMultisampleRate = " + ss[53].str() + "\n" + prefix + "inheritedQueries = " + ss[54].str() + "\n"; 3451 return final_str; 3452} 3453// CODEGEN : file ../vk_helper.py line #906 3454std::string vk_print_vkphysicaldevicelimits(const VkPhysicalDeviceLimits* pStruct, const std::string prefix) 3455{ 3456// CODEGEN : file ../vk_helper.py line #912 3457 using namespace StreamControl; 3458 using namespace std; 3459 string final_str; 3460 string tmp_str; 3461 string extra_indent = " " + prefix; 3462 stringstream ss[106]; 3463 string stp_strs[6]; 3464// CODEGEN : file ../vk_helper.py line #931 3465// CODEGEN : file ../vk_helper.py line #936 3466// CODEGEN : file ../vk_helper.py line #938 3467 stp_strs[0] = ""; 3468 stringstream index_ss; 3469 for (uint32_t i = 0; i < 3; i++) { 3470 index_ss.str(""); 3471 index_ss << i; 3472// CODEGEN : file ../vk_helper.py line #989 3473 ss[0] << pStruct->maxComputeWorkGroupCount[i]; 3474 stp_strs[0] += " " + prefix + "maxComputeWorkGroupCount[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 3475// CODEGEN : file ../vk_helper.py line #999 3476 ss[0].str(""); 3477 } 3478// CODEGEN : file ../vk_helper.py line #931 3479// CODEGEN : file ../vk_helper.py line #936 3480// CODEGEN : file ../vk_helper.py line #938 3481 stp_strs[1] = ""; 3482 for (uint32_t i = 0; i < 3; i++) { 3483 index_ss.str(""); 3484 index_ss << i; 3485// CODEGEN : file ../vk_helper.py line #989 3486 ss[1] << pStruct->maxComputeWorkGroupSize[i]; 3487 stp_strs[1] += " " + prefix + "maxComputeWorkGroupSize[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 3488// CODEGEN : file ../vk_helper.py line #999 3489 ss[1].str(""); 3490 } 3491// CODEGEN : file ../vk_helper.py line #931 3492// CODEGEN : file ../vk_helper.py line #936 3493// CODEGEN : file ../vk_helper.py line #938 3494 stp_strs[2] = ""; 3495 for (uint32_t i = 0; i < 2; i++) { 3496 index_ss.str(""); 3497 index_ss << i; 3498// CODEGEN : file ../vk_helper.py line #989 3499 ss[2] << pStruct->maxViewportDimensions[i]; 3500 stp_strs[2] += " " + prefix + "maxViewportDimensions[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 3501// CODEGEN : file ../vk_helper.py line #999 3502 ss[2].str(""); 3503 } 3504// CODEGEN : file ../vk_helper.py line #931 3505// CODEGEN : file ../vk_helper.py line #936 3506// CODEGEN : file ../vk_helper.py line #938 3507 stp_strs[3] = ""; 3508 for (uint32_t i = 0; i < 2; i++) { 3509 index_ss.str(""); 3510 index_ss << i; 3511// CODEGEN : file ../vk_helper.py line #989 3512 ss[3] << pStruct->viewportBoundsRange[i]; 3513 stp_strs[3] += " " + prefix + "viewportBoundsRange[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 3514// CODEGEN : file ../vk_helper.py line #999 3515 ss[3].str(""); 3516 } 3517// CODEGEN : file ../vk_helper.py line #931 3518// CODEGEN : file ../vk_helper.py line #936 3519// CODEGEN : file ../vk_helper.py line #938 3520 stp_strs[4] = ""; 3521 for (uint32_t i = 0; i < 2; i++) { 3522 index_ss.str(""); 3523 index_ss << i; 3524// CODEGEN : file ../vk_helper.py line #989 3525 ss[4] << pStruct->pointSizeRange[i]; 3526 stp_strs[4] += " " + prefix + "pointSizeRange[" + index_ss.str() + "] = " + ss[4].str() + "\n"; 3527// CODEGEN : file ../vk_helper.py line #999 3528 ss[4].str(""); 3529 } 3530// CODEGEN : file ../vk_helper.py line #931 3531// CODEGEN : file ../vk_helper.py line #936 3532// CODEGEN : file ../vk_helper.py line #938 3533 stp_strs[5] = ""; 3534 for (uint32_t i = 0; i < 2; i++) { 3535 index_ss.str(""); 3536 index_ss << i; 3537// CODEGEN : file ../vk_helper.py line #989 3538 ss[5] << pStruct->lineWidthRange[i]; 3539 stp_strs[5] += " " + prefix + "lineWidthRange[" + index_ss.str() + "] = " + ss[5].str() + "\n"; 3540// CODEGEN : file ../vk_helper.py line #999 3541 ss[5].str(""); 3542 } 3543// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3544 ss[0] << pStruct->maxImageDimension1D; 3545// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3546 ss[1] << pStruct->maxImageDimension2D; 3547// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3548 ss[2] << pStruct->maxImageDimension3D; 3549// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3550 ss[3] << pStruct->maxImageDimensionCube; 3551// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3552 ss[4] << pStruct->maxImageArrayLayers; 3553// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3554 ss[5] << "0x" << pStruct->maxTexelBufferElements; 3555// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3556 ss[6] << "0x" << pStruct->maxUniformBufferRange; 3557// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3558 ss[7] << "0x" << pStruct->maxStorageBufferRange; 3559// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3560 ss[8] << pStruct->maxPushConstantsSize; 3561// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3562 ss[9] << pStruct->maxMemoryAllocationCount; 3563// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3564 ss[10] << pStruct->maxSamplerAllocationCount; 3565// CODEGEN : file ../vk_helper.py line #1085 3566 ss[11] << "0x" << pStruct->bufferImageGranularity; 3567// CODEGEN : file ../vk_helper.py line #1085 3568 ss[12] << "0x" << pStruct->sparseAddressSpaceSize; 3569// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3570 ss[13] << pStruct->maxBoundDescriptorSets; 3571// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3572 ss[14] << pStruct->maxPerStageDescriptorSamplers; 3573// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3574 ss[15] << "0x" << pStruct->maxPerStageDescriptorUniformBuffers; 3575// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3576 ss[16] << "0x" << pStruct->maxPerStageDescriptorStorageBuffers; 3577// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3578 ss[17] << pStruct->maxPerStageDescriptorSampledImages; 3579// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3580 ss[18] << pStruct->maxPerStageDescriptorStorageImages; 3581// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3582 ss[19] << pStruct->maxPerStageDescriptorInputAttachments; 3583// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3584 ss[20] << pStruct->maxPerStageResources; 3585// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3586 ss[21] << pStruct->maxDescriptorSetSamplers; 3587// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3588 ss[22] << "0x" << pStruct->maxDescriptorSetUniformBuffers; 3589// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3590 ss[23] << "0x" << pStruct->maxDescriptorSetUniformBuffersDynamic; 3591// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3592 ss[24] << "0x" << pStruct->maxDescriptorSetStorageBuffers; 3593// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3594 ss[25] << "0x" << pStruct->maxDescriptorSetStorageBuffersDynamic; 3595// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3596 ss[26] << pStruct->maxDescriptorSetSampledImages; 3597// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3598 ss[27] << pStruct->maxDescriptorSetStorageImages; 3599// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3600 ss[28] << pStruct->maxDescriptorSetInputAttachments; 3601// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3602 ss[29] << pStruct->maxVertexInputAttributes; 3603// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3604 ss[30] << pStruct->maxVertexInputBindings; 3605// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3606 ss[31] << "0x" << pStruct->maxVertexInputAttributeOffset; 3607// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3608 ss[32] << pStruct->maxVertexInputBindingStride; 3609// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3610 ss[33] << pStruct->maxVertexOutputComponents; 3611// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3612 ss[34] << pStruct->maxTessellationGenerationLevel; 3613// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3614 ss[35] << pStruct->maxTessellationPatchSize; 3615// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3616 ss[36] << pStruct->maxTessellationControlPerVertexInputComponents; 3617// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3618 ss[37] << pStruct->maxTessellationControlPerVertexOutputComponents; 3619// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3620 ss[38] << pStruct->maxTessellationControlPerPatchOutputComponents; 3621// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3622 ss[39] << pStruct->maxTessellationControlTotalOutputComponents; 3623// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3624 ss[40] << pStruct->maxTessellationEvaluationInputComponents; 3625// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3626 ss[41] << pStruct->maxTessellationEvaluationOutputComponents; 3627// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3628 ss[42] << pStruct->maxGeometryShaderInvocations; 3629// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3630 ss[43] << pStruct->maxGeometryInputComponents; 3631// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3632 ss[44] << pStruct->maxGeometryOutputComponents; 3633// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3634 ss[45] << pStruct->maxGeometryOutputVertices; 3635// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3636 ss[46] << pStruct->maxGeometryTotalOutputComponents; 3637// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3638 ss[47] << pStruct->maxFragmentInputComponents; 3639// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3640 ss[48] << pStruct->maxFragmentOutputAttachments; 3641// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3642 ss[49] << pStruct->maxFragmentDualSrcAttachments; 3643// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3644 ss[50] << pStruct->maxFragmentCombinedOutputResources; 3645// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3646 ss[51] << pStruct->maxComputeSharedMemorySize; 3647// CODEGEN : file ../vk_helper.py line #1060 3648 ss[52] << "0x" << (void*)pStruct->maxComputeWorkGroupCount; 3649// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3650 ss[53] << pStruct->maxComputeWorkGroupInvocations; 3651// CODEGEN : file ../vk_helper.py line #1060 3652 ss[54] << "0x" << (void*)pStruct->maxComputeWorkGroupSize; 3653// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3654 ss[55] << "0x" << pStruct->subPixelPrecisionBits; 3655// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3656 ss[56] << "0x" << pStruct->subTexelPrecisionBits; 3657// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3658 ss[57] << "0x" << pStruct->mipmapPrecisionBits; 3659// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3660 ss[58] << pStruct->maxDrawIndexedIndexValue; 3661// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3662 ss[59] << pStruct->maxDrawIndirectCount; 3663// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3664 ss[60] << pStruct->maxSamplerLodBias; 3665// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3666 ss[61] << pStruct->maxSamplerAnisotropy; 3667// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3668 ss[62] << pStruct->maxViewports; 3669// CODEGEN : file ../vk_helper.py line #1060 3670 ss[63] << "0x" << (void*)pStruct->maxViewportDimensions; 3671// CODEGEN : file ../vk_helper.py line #1060 3672 ss[64] << "0x" << (void*)pStruct->viewportBoundsRange; 3673// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3674 ss[65] << "0x" << pStruct->viewportSubPixelBits; 3675// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3676 ss[66] << pStruct->minMemoryMapAlignment; 3677// CODEGEN : file ../vk_helper.py line #1085 3678 ss[67] << "0x" << pStruct->minTexelBufferOffsetAlignment; 3679// CODEGEN : file ../vk_helper.py line #1085 3680 ss[68] << "0x" << pStruct->minUniformBufferOffsetAlignment; 3681// CODEGEN : file ../vk_helper.py line #1085 3682 ss[69] << "0x" << pStruct->minStorageBufferOffsetAlignment; 3683// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3684 ss[70] << "0x" << pStruct->minTexelOffset; 3685// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3686 ss[71] << "0x" << pStruct->maxTexelOffset; 3687// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3688 ss[72] << "0x" << pStruct->minTexelGatherOffset; 3689// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3690 ss[73] << "0x" << pStruct->maxTexelGatherOffset; 3691// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3692 ss[74] << "0x" << pStruct->minInterpolationOffset; 3693// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3694 ss[75] << "0x" << pStruct->maxInterpolationOffset; 3695// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3696 ss[76] << "0x" << pStruct->subPixelInterpolationOffsetBits; 3697// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3698 ss[77] << "0x" << pStruct->maxFramebufferWidth; 3699// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3700 ss[78] << "0x" << pStruct->maxFramebufferHeight; 3701// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3702 ss[79] << "0x" << pStruct->maxFramebufferLayers; 3703// CODEGEN : file ../vk_helper.py line #1085 3704 ss[80] << "0x" << pStruct->framebufferColorSampleCounts; 3705// CODEGEN : file ../vk_helper.py line #1085 3706 ss[81] << "0x" << pStruct->framebufferDepthSampleCounts; 3707// CODEGEN : file ../vk_helper.py line #1085 3708 ss[82] << "0x" << pStruct->framebufferStencilSampleCounts; 3709// CODEGEN : file ../vk_helper.py line #1085 3710 ss[83] << "0x" << pStruct->framebufferNoAttachmentsSampleCounts; 3711// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3712 ss[84] << pStruct->maxColorAttachments; 3713// CODEGEN : file ../vk_helper.py line #1085 3714 ss[85] << "0x" << pStruct->sampledImageColorSampleCounts; 3715// CODEGEN : file ../vk_helper.py line #1085 3716 ss[86] << "0x" << pStruct->sampledImageIntegerSampleCounts; 3717// CODEGEN : file ../vk_helper.py line #1085 3718 ss[87] << "0x" << pStruct->sampledImageDepthSampleCounts; 3719// CODEGEN : file ../vk_helper.py line #1085 3720 ss[88] << "0x" << pStruct->sampledImageStencilSampleCounts; 3721// CODEGEN : file ../vk_helper.py line #1085 3722 ss[89] << "0x" << pStruct->storageImageSampleCounts; 3723// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3724 ss[90] << "0x" << pStruct->maxSampleMaskWords; 3725// CODEGEN : file ../vk_helper.py line #1063 3726 ss[91].str(pStruct->timestampComputeAndGraphics ? "TRUE" : "FALSE"); 3727// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3728 ss[92] << pStruct->timestampPeriod; 3729// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3730 ss[93] << pStruct->maxClipDistances; 3731// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3732 ss[94] << pStruct->maxCullDistances; 3733// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3734 ss[95] << pStruct->maxCombinedClipAndCullDistances; 3735// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3736 ss[96] << pStruct->discreteQueuePriorities; 3737// CODEGEN : file ../vk_helper.py line #1060 3738 ss[97] << "0x" << (void*)pStruct->pointSizeRange; 3739// CODEGEN : file ../vk_helper.py line #1060 3740 ss[98] << "0x" << (void*)pStruct->lineWidthRange; 3741// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3742 ss[99] << pStruct->pointSizeGranularity; 3743// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3744 ss[100] << pStruct->lineWidthGranularity; 3745// CODEGEN : file ../vk_helper.py line #1063 3746 ss[101].str(pStruct->strictLines ? "TRUE" : "FALSE"); 3747// CODEGEN : file ../vk_helper.py line #1063 3748 ss[102].str(pStruct->standardSampleLocations ? "TRUE" : "FALSE"); 3749// CODEGEN : file ../vk_helper.py line #1085 3750 ss[103] << "0x" << pStruct->optimalBufferCopyOffsetAlignment; 3751// CODEGEN : file ../vk_helper.py line #1085 3752 ss[104] << "0x" << pStruct->optimalBufferCopyRowPitchAlignment; 3753// CODEGEN : file ../vk_helper.py line #1085 3754 ss[105] << "0x" << pStruct->nonCoherentAtomSize; 3755// CODEGEN : file ../vk_helper.py line #1113 3756 final_str = prefix + "maxImageDimension1D = " + ss[0].str() + "\n" + prefix + "maxImageDimension2D = " + ss[1].str() + "\n" + prefix + "maxImageDimension3D = " + ss[2].str() + "\n" + prefix + "maxImageDimensionCube = " + ss[3].str() + "\n" + prefix + "maxImageArrayLayers = " + ss[4].str() + "\n" + prefix + "maxTexelBufferElements = " + ss[5].str() + "\n" + prefix + "maxUniformBufferRange = " + ss[6].str() + "\n" + prefix + "maxStorageBufferRange = " + ss[7].str() + "\n" + prefix + "maxPushConstantsSize = " + ss[8].str() + "\n" + prefix + "maxMemoryAllocationCount = " + ss[9].str() + "\n" + prefix + "maxSamplerAllocationCount = " + ss[10].str() + "\n" + prefix + "bufferImageGranularity = " + ss[11].str() + "\n" + prefix + "sparseAddressSpaceSize = " + ss[12].str() + "\n" + prefix + "maxBoundDescriptorSets = " + ss[13].str() + "\n" + prefix + "maxPerStageDescriptorSamplers = " + ss[14].str() + "\n" + prefix + "maxPerStageDescriptorUniformBuffers = " + ss[15].str() + "\n" + prefix + "maxPerStageDescriptorStorageBuffers = " + ss[16].str() + "\n" + prefix + "maxPerStageDescriptorSampledImages = " + ss[17].str() + "\n" + prefix + "maxPerStageDescriptorStorageImages = " + ss[18].str() + "\n" + prefix + "maxPerStageDescriptorInputAttachments = " + ss[19].str() + "\n" + prefix + "maxPerStageResources = " + ss[20].str() + "\n" + prefix + "maxDescriptorSetSamplers = " + ss[21].str() + "\n" + prefix + "maxDescriptorSetUniformBuffers = " + ss[22].str() + "\n" + prefix + "maxDescriptorSetUniformBuffersDynamic = " + ss[23].str() + "\n" + prefix + "maxDescriptorSetStorageBuffers = " + ss[24].str() + "\n" + prefix + "maxDescriptorSetStorageBuffersDynamic = " + ss[25].str() + "\n" + prefix + "maxDescriptorSetSampledImages = " + ss[26].str() + "\n" + prefix + "maxDescriptorSetStorageImages = " + ss[27].str() + "\n" + prefix + "maxDescriptorSetInputAttachments = " + ss[28].str() + "\n" + prefix + "maxVertexInputAttributes = " + ss[29].str() + "\n" + prefix + "maxVertexInputBindings = " + ss[30].str() + "\n" + prefix + "maxVertexInputAttributeOffset = " + ss[31].str() + "\n" + prefix + "maxVertexInputBindingStride = " + ss[32].str() + "\n" + prefix + "maxVertexOutputComponents = " + ss[33].str() + "\n" + prefix + "maxTessellationGenerationLevel = " + ss[34].str() + "\n" + prefix + "maxTessellationPatchSize = " + ss[35].str() + "\n" + prefix + "maxTessellationControlPerVertexInputComponents = " + ss[36].str() + "\n" + prefix + "maxTessellationControlPerVertexOutputComponents = " + ss[37].str() + "\n" + prefix + "maxTessellationControlPerPatchOutputComponents = " + ss[38].str() + "\n" + prefix + "maxTessellationControlTotalOutputComponents = " + ss[39].str() + "\n" + prefix + "maxTessellationEvaluationInputComponents = " + ss[40].str() + "\n" + prefix + "maxTessellationEvaluationOutputComponents = " + ss[41].str() + "\n" + prefix + "maxGeometryShaderInvocations = " + ss[42].str() + "\n" + prefix + "maxGeometryInputComponents = " + ss[43].str() + "\n" + prefix + "maxGeometryOutputComponents = " + ss[44].str() + "\n" + prefix + "maxGeometryOutputVertices = " + ss[45].str() + "\n" + prefix + "maxGeometryTotalOutputComponents = " + ss[46].str() + "\n" + prefix + "maxFragmentInputComponents = " + ss[47].str() + "\n" + prefix + "maxFragmentOutputAttachments = " + ss[48].str() + "\n" + prefix + "maxFragmentDualSrcAttachments = " + ss[49].str() + "\n" + prefix + "maxFragmentCombinedOutputResources = " + ss[50].str() + "\n" + prefix + "maxComputeSharedMemorySize = " + ss[51].str() + "\n" + prefix + "maxComputeWorkGroupCount = " + ss[52].str() + "\n" + prefix + "maxComputeWorkGroupInvocations = " + ss[53].str() + "\n" + prefix + "maxComputeWorkGroupSize = " + ss[54].str() + "\n" + prefix + "subPixelPrecisionBits = " + ss[55].str() + "\n" + prefix + "subTexelPrecisionBits = " + ss[56].str() + "\n" + prefix + "mipmapPrecisionBits = " + ss[57].str() + "\n" + prefix + "maxDrawIndexedIndexValue = " + ss[58].str() + "\n" + prefix + "maxDrawIndirectCount = " + ss[59].str() + "\n" + prefix + "maxSamplerLodBias = " + ss[60].str() + "\n" + prefix + "maxSamplerAnisotropy = " + ss[61].str() + "\n" + prefix + "maxViewports = " + ss[62].str() + "\n" + prefix + "maxViewportDimensions = " + ss[63].str() + "\n" + prefix + "viewportBoundsRange = " + ss[64].str() + "\n" + prefix + "viewportSubPixelBits = " + ss[65].str() + "\n" + prefix + "minMemoryMapAlignment = " + ss[66].str() + "\n" + prefix + "minTexelBufferOffsetAlignment = " + ss[67].str() + "\n" + prefix + "minUniformBufferOffsetAlignment = " + ss[68].str() + "\n" + prefix + "minStorageBufferOffsetAlignment = " + ss[69].str() + "\n" + prefix + "minTexelOffset = " + ss[70].str() + "\n" + prefix + "maxTexelOffset = " + ss[71].str() + "\n" + prefix + "minTexelGatherOffset = " + ss[72].str() + "\n" + prefix + "maxTexelGatherOffset = " + ss[73].str() + "\n" + prefix + "minInterpolationOffset = " + ss[74].str() + "\n" + prefix + "maxInterpolationOffset = " + ss[75].str() + "\n" + prefix + "subPixelInterpolationOffsetBits = " + ss[76].str() + "\n" + prefix + "maxFramebufferWidth = " + ss[77].str() + "\n" + prefix + "maxFramebufferHeight = " + ss[78].str() + "\n" + prefix + "maxFramebufferLayers = " + ss[79].str() + "\n" + prefix + "framebufferColorSampleCounts = " + ss[80].str() + "\n" + prefix + "framebufferDepthSampleCounts = " + ss[81].str() + "\n" + prefix + "framebufferStencilSampleCounts = " + ss[82].str() + "\n" + prefix + "framebufferNoAttachmentsSampleCounts = " + ss[83].str() + "\n" + prefix + "maxColorAttachments = " + ss[84].str() + "\n" + prefix + "sampledImageColorSampleCounts = " + ss[85].str() + "\n" + prefix + "sampledImageIntegerSampleCounts = " + ss[86].str() + "\n" + prefix + "sampledImageDepthSampleCounts = " + ss[87].str() + "\n" + prefix + "sampledImageStencilSampleCounts = " + ss[88].str() + "\n" + prefix + "storageImageSampleCounts = " + ss[89].str() + "\n" + prefix + "maxSampleMaskWords = " + ss[90].str() + "\n" + prefix + "timestampComputeAndGraphics = " + ss[91].str() + "\n" + prefix + "timestampPeriod = " + ss[92].str() + "\n" + prefix + "maxClipDistances = " + ss[93].str() + "\n" + prefix + "maxCullDistances = " + ss[94].str() + "\n" + prefix + "maxCombinedClipAndCullDistances = " + ss[95].str() + "\n" + prefix + "discreteQueuePriorities = " + ss[96].str() + "\n" + prefix + "pointSizeRange = " + ss[97].str() + "\n" + prefix + "lineWidthRange = " + ss[98].str() + "\n" + prefix + "pointSizeGranularity = " + ss[99].str() + "\n" + prefix + "lineWidthGranularity = " + ss[100].str() + "\n" + prefix + "strictLines = " + ss[101].str() + "\n" + prefix + "standardSampleLocations = " + ss[102].str() + "\n" + prefix + "optimalBufferCopyOffsetAlignment = " + ss[103].str() + "\n" + prefix + "optimalBufferCopyRowPitchAlignment = " + ss[104].str() + "\n" + prefix + "nonCoherentAtomSize = " + ss[105].str() + "\n" + stp_strs[5] + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3757 return final_str; 3758} 3759// CODEGEN : file ../vk_helper.py line #906 3760std::string vk_print_vkphysicaldevicememoryproperties(const VkPhysicalDeviceMemoryProperties* pStruct, const std::string prefix) 3761{ 3762// CODEGEN : file ../vk_helper.py line #912 3763 using namespace StreamControl; 3764 using namespace std; 3765 string final_str; 3766 string tmp_str; 3767 string extra_indent = " " + prefix; 3768 stringstream ss[4]; 3769 string stp_strs[2]; 3770// CODEGEN : file ../vk_helper.py line #931 3771// CODEGEN : file ../vk_helper.py line #936 3772// CODEGEN : file ../vk_helper.py line #938 3773 stp_strs[0] = ""; 3774 stringstream index_ss; 3775 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) { 3776 index_ss.str(""); 3777 index_ss << i; 3778// CODEGEN : file ../vk_helper.py line #979 3779 ss[0] << "0x" << &pStruct->memoryTypes[i]; 3780 tmp_str = vk_print_vkmemorytype(&pStruct->memoryTypes[i], extra_indent); 3781// CODEGEN : file ../vk_helper.py line #983 3782 stp_strs[0] += " " + prefix + "memoryTypes[" + index_ss.str() + "] (addr)\n" + tmp_str; 3783// CODEGEN : file ../vk_helper.py line #999 3784 ss[0].str(""); 3785 } 3786// CODEGEN : file ../vk_helper.py line #931 3787// CODEGEN : file ../vk_helper.py line #936 3788// CODEGEN : file ../vk_helper.py line #938 3789 stp_strs[1] = ""; 3790 for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { 3791 index_ss.str(""); 3792 index_ss << i; 3793// CODEGEN : file ../vk_helper.py line #979 3794 ss[1] << "0x" << &pStruct->memoryHeaps[i]; 3795 tmp_str = vk_print_vkmemoryheap(&pStruct->memoryHeaps[i], extra_indent); 3796// CODEGEN : file ../vk_helper.py line #983 3797 stp_strs[1] += " " + prefix + "memoryHeaps[" + index_ss.str() + "] (addr)\n" + tmp_str; 3798// CODEGEN : file ../vk_helper.py line #999 3799 ss[1].str(""); 3800 } 3801// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3802 ss[0] << pStruct->memoryTypeCount; 3803// CODEGEN : file ../vk_helper.py line #1054 3804 ss[1].str("addr"); 3805// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3806 ss[2] << pStruct->memoryHeapCount; 3807// CODEGEN : file ../vk_helper.py line #1054 3808 ss[3].str("addr"); 3809// CODEGEN : file ../vk_helper.py line #1113 3810 final_str = prefix + "memoryTypeCount = " + ss[0].str() + "\n" + prefix + "memoryTypes = " + ss[1].str() + "\n" + prefix + "memoryHeapCount = " + ss[2].str() + "\n" + prefix + "memoryHeaps = " + ss[3].str() + "\n" + stp_strs[1] + stp_strs[0]; 3811 return final_str; 3812} 3813// CODEGEN : file ../vk_helper.py line #906 3814std::string vk_print_vkphysicaldeviceproperties(const VkPhysicalDeviceProperties* pStruct, const std::string prefix) 3815{ 3816// CODEGEN : file ../vk_helper.py line #912 3817 using namespace StreamControl; 3818 using namespace std; 3819 string final_str; 3820 string tmp_str; 3821 string extra_indent = " " + prefix; 3822 stringstream ss[8]; 3823 string stp_strs[4]; 3824// CODEGEN : file ../vk_helper.py line #931 3825// CODEGEN : file ../vk_helper.py line #936 3826// CODEGEN : file ../vk_helper.py line #938 3827 stp_strs[0] = ""; 3828 stringstream index_ss; 3829 for (uint32_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++) { 3830 index_ss.str(""); 3831 index_ss << i; 3832// CODEGEN : file ../vk_helper.py line #989 3833 ss[0] << pStruct->deviceName[i]; 3834 stp_strs[0] += " " + prefix + "deviceName[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 3835// CODEGEN : file ../vk_helper.py line #999 3836 ss[0].str(""); 3837 } 3838// CODEGEN : file ../vk_helper.py line #931 3839// CODEGEN : file ../vk_helper.py line #936 3840// CODEGEN : file ../vk_helper.py line #938 3841 stp_strs[1] = ""; 3842 for (uint32_t i = 0; i < VK_UUID_SIZE; i++) { 3843 index_ss.str(""); 3844 index_ss << i; 3845// CODEGEN : file ../vk_helper.py line #989 3846 ss[1] << "0x" << pStruct->pipelineCacheUUID[i]; 3847 stp_strs[1] += " " + prefix + "pipelineCacheUUID[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 3848// CODEGEN : file ../vk_helper.py line #999 3849 ss[1].str(""); 3850 } 3851// CODEGEN : file ../vk_helper.py line #1037 3852 tmp_str = vk_print_vkphysicaldevicelimits(&pStruct->limits, extra_indent); 3853 ss[2] << "0x" << &pStruct->limits; 3854 stp_strs[2] = " " + prefix + "limits (addr)\n" + tmp_str; 3855// CODEGEN : file ../vk_helper.py line #1042 3856 ss[2].str(""); 3857// CODEGEN : file ../vk_helper.py line #1037 3858 tmp_str = vk_print_vkphysicaldevicesparseproperties(&pStruct->sparseProperties, extra_indent); 3859 ss[3] << "0x" << &pStruct->sparseProperties; 3860 stp_strs[3] = " " + prefix + "sparseProperties (addr)\n" + tmp_str; 3861// CODEGEN : file ../vk_helper.py line #1042 3862 ss[3].str(""); 3863// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3864 ss[0] << pStruct->apiVersion; 3865// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3866 ss[1] << pStruct->driverVersion; 3867// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3868 ss[2] << "0x" << pStruct->vendorID; 3869// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 3870 ss[3] << "0x" << pStruct->deviceID; 3871// CODEGEN : file ../vk_helper.py line #1060 3872 ss[4] << "0x" << (void*)pStruct->deviceName; 3873// CODEGEN : file ../vk_helper.py line #1060 3874 ss[5] << "0x" << (void*)pStruct->pipelineCacheUUID; 3875// CODEGEN : file ../vk_helper.py line #1054 3876 ss[6].str("addr"); 3877// CODEGEN : file ../vk_helper.py line #1054 3878 ss[7].str("addr"); 3879// CODEGEN : file ../vk_helper.py line #1113 3880 final_str = prefix + "apiVersion = " + ss[0].str() + "\n" + prefix + "driverVersion = " + ss[1].str() + "\n" + prefix + "vendorID = " + ss[2].str() + "\n" + prefix + "deviceID = " + ss[3].str() + "\n" + prefix + "deviceType = " + string_VkPhysicalDeviceType(pStruct->deviceType) + "\n" + prefix + "deviceName = " + ss[4].str() + "\n" + prefix + "pipelineCacheUUID = " + ss[5].str() + "\n" + prefix + "limits = " + ss[6].str() + "\n" + prefix + "sparseProperties = " + ss[7].str() + "\n" + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3881 return final_str; 3882} 3883// CODEGEN : file ../vk_helper.py line #906 3884std::string vk_print_vkphysicaldevicesparseproperties(const VkPhysicalDeviceSparseProperties* pStruct, const std::string prefix) 3885{ 3886// CODEGEN : file ../vk_helper.py line #912 3887 using namespace StreamControl; 3888 using namespace std; 3889 string final_str; 3890 string tmp_str; 3891 string extra_indent = " " + prefix; 3892 stringstream ss[5]; 3893// CODEGEN : file ../vk_helper.py line #1063 3894 ss[0].str(pStruct->residencyStandard2DBlockShape ? "TRUE" : "FALSE"); 3895// CODEGEN : file ../vk_helper.py line #1063 3896 ss[1].str(pStruct->residencyStandard2DMultisampleBlockShape ? "TRUE" : "FALSE"); 3897// CODEGEN : file ../vk_helper.py line #1063 3898 ss[2].str(pStruct->residencyStandard3DBlockShape ? "TRUE" : "FALSE"); 3899// CODEGEN : file ../vk_helper.py line #1063 3900 ss[3].str(pStruct->residencyAlignedMipSize ? "TRUE" : "FALSE"); 3901// CODEGEN : file ../vk_helper.py line #1063 3902 ss[4].str(pStruct->residencyNonResidentStrict ? "TRUE" : "FALSE"); 3903// CODEGEN : file ../vk_helper.py line #1113 3904 final_str = prefix + "residencyStandard2DBlockShape = " + ss[0].str() + "\n" + prefix + "residencyStandard2DMultisampleBlockShape = " + ss[1].str() + "\n" + prefix + "residencyStandard3DBlockShape = " + ss[2].str() + "\n" + prefix + "residencyAlignedMipSize = " + ss[3].str() + "\n" + prefix + "residencyNonResidentStrict = " + ss[4].str() + "\n"; 3905 return final_str; 3906} 3907// CODEGEN : file ../vk_helper.py line #906 3908std::string vk_print_vkpipelinecachecreateinfo(const VkPipelineCacheCreateInfo* pStruct, const std::string prefix) 3909{ 3910// CODEGEN : file ../vk_helper.py line #912 3911 using namespace StreamControl; 3912 using namespace std; 3913 string final_str; 3914 string tmp_str; 3915 string extra_indent = " " + prefix; 3916 stringstream ss[4]; 3917 string stp_strs[1]; 3918// CODEGEN : file ../vk_helper.py line #1011 3919 if (pStruct->pNext) { 3920// CODEGEN : file ../vk_helper.py line #1015 3921 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3922 ss[0] << "0x" << &pStruct->pNext; 3923// CODEGEN : file ../vk_helper.py line #1027 3924 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3925 ss[0].str(""); 3926 } 3927 else 3928 stp_strs[0] = ""; 3929// CODEGEN : file ../vk_helper.py line #1069 3930 if (StreamControl::writeAddress) 3931 ss[0] << "0x" << pStruct->pNext; 3932 else 3933 ss[0].str("address"); 3934// CODEGEN : file ../vk_helper.py line #1085 3935 ss[1] << "0x" << pStruct->flags; 3936// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 3937 ss[2] << pStruct->initialDataSize; 3938// CODEGEN : file ../vk_helper.py line #1069 3939 if (StreamControl::writeAddress) 3940 ss[3] << "0x" << pStruct->pInitialData; 3941 else 3942 ss[3].str("address"); 3943// CODEGEN : file ../vk_helper.py line #1113 3944 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "initialDataSize = " + ss[2].str() + "\n" + prefix + "pInitialData = " + ss[3].str() + "\n" + stp_strs[0]; 3945 return final_str; 3946} 3947// CODEGEN : file ../vk_helper.py line #906 3948std::string vk_print_vkpipelinecolorblendattachmentstate(const VkPipelineColorBlendAttachmentState* pStruct, const std::string prefix) 3949{ 3950// CODEGEN : file ../vk_helper.py line #912 3951 using namespace StreamControl; 3952 using namespace std; 3953 string final_str; 3954 string tmp_str; 3955 string extra_indent = " " + prefix; 3956 stringstream ss[2]; 3957// CODEGEN : file ../vk_helper.py line #1063 3958 ss[0].str(pStruct->blendEnable ? "TRUE" : "FALSE"); 3959// CODEGEN : file ../vk_helper.py line #1085 3960 ss[1] << "0x" << pStruct->colorWriteMask; 3961// CODEGEN : file ../vk_helper.py line #1113 3962 final_str = prefix + "blendEnable = " + ss[0].str() + "\n" + prefix + "srcColorBlendFactor = " + string_VkBlendFactor(pStruct->srcColorBlendFactor) + "\n" + prefix + "dstColorBlendFactor = " + string_VkBlendFactor(pStruct->dstColorBlendFactor) + "\n" + prefix + "colorBlendOp = " + string_VkBlendOp(pStruct->colorBlendOp) + "\n" + prefix + "srcAlphaBlendFactor = " + string_VkBlendFactor(pStruct->srcAlphaBlendFactor) + "\n" + prefix + "dstAlphaBlendFactor = " + string_VkBlendFactor(pStruct->dstAlphaBlendFactor) + "\n" + prefix + "alphaBlendOp = " + string_VkBlendOp(pStruct->alphaBlendOp) + "\n" + prefix + "colorWriteMask = " + ss[1].str() + "\n"; 3963 return final_str; 3964} 3965// CODEGEN : file ../vk_helper.py line #906 3966std::string vk_print_vkpipelinecolorblendstatecreateinfo(const VkPipelineColorBlendStateCreateInfo* pStruct, const std::string prefix) 3967{ 3968// CODEGEN : file ../vk_helper.py line #912 3969 using namespace StreamControl; 3970 using namespace std; 3971 string final_str; 3972 string tmp_str; 3973 string extra_indent = " " + prefix; 3974 stringstream ss[6]; 3975 string stp_strs[3]; 3976// CODEGEN : file ../vk_helper.py line #1011 3977 if (pStruct->pNext) { 3978// CODEGEN : file ../vk_helper.py line #1015 3979 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3980 ss[0] << "0x" << &pStruct->pNext; 3981// CODEGEN : file ../vk_helper.py line #1027 3982 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3983 ss[0].str(""); 3984 } 3985 else 3986 stp_strs[0] = ""; 3987// CODEGEN : file ../vk_helper.py line #931 3988// CODEGEN : file ../vk_helper.py line #933 3989// CODEGEN : file ../vk_helper.py line #938 3990 stp_strs[1] = ""; 3991 stringstream index_ss; 3992 if (pStruct->pAttachments) { 3993 for (uint32_t i = 0; i < pStruct->attachmentCount; i++) { 3994 index_ss.str(""); 3995 index_ss << i; 3996// CODEGEN : file ../vk_helper.py line #979 3997 ss[1] << "0x" << &pStruct->pAttachments[i]; 3998 tmp_str = vk_print_vkpipelinecolorblendattachmentstate(&pStruct->pAttachments[i], extra_indent); 3999// CODEGEN : file ../vk_helper.py line #983 4000 stp_strs[1] += " " + prefix + "pAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 4001// CODEGEN : file ../vk_helper.py line #999 4002 ss[1].str(""); 4003 } 4004 } 4005// CODEGEN : file ../vk_helper.py line #931 4006// CODEGEN : file ../vk_helper.py line #936 4007// CODEGEN : file ../vk_helper.py line #938 4008 stp_strs[2] = ""; 4009 for (uint32_t i = 0; i < 4; i++) { 4010 index_ss.str(""); 4011 index_ss << i; 4012// CODEGEN : file ../vk_helper.py line #989 4013 ss[2] << pStruct->blendConstants[i]; 4014 stp_strs[2] += " " + prefix + "blendConstants[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 4015// CODEGEN : file ../vk_helper.py line #999 4016 ss[2].str(""); 4017 } 4018// CODEGEN : file ../vk_helper.py line #1069 4019 if (StreamControl::writeAddress) 4020 ss[0] << "0x" << pStruct->pNext; 4021 else 4022 ss[0].str("address"); 4023// CODEGEN : file ../vk_helper.py line #1085 4024 ss[1] << "0x" << pStruct->flags; 4025// CODEGEN : file ../vk_helper.py line #1063 4026 ss[2].str(pStruct->logicOpEnable ? "TRUE" : "FALSE"); 4027// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4028 ss[3] << pStruct->attachmentCount; 4029// CODEGEN : file ../vk_helper.py line #1060 4030 ss[4] << "0x" << (void*)pStruct->pAttachments; 4031// CODEGEN : file ../vk_helper.py line #1060 4032 ss[5] << "0x" << (void*)pStruct->blendConstants; 4033// CODEGEN : file ../vk_helper.py line #1113 4034 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "logicOpEnable = " + ss[2].str() + "\n" + prefix + "logicOp = " + string_VkLogicOp(pStruct->logicOp) + "\n" + prefix + "attachmentCount = " + ss[3].str() + "\n" + prefix + "pAttachments = " + ss[4].str() + "\n" + prefix + "blendConstants = " + ss[5].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4035 return final_str; 4036} 4037// CODEGEN : file ../vk_helper.py line #906 4038std::string vk_print_vkpipelinedepthstencilstatecreateinfo(const VkPipelineDepthStencilStateCreateInfo* pStruct, const std::string prefix) 4039{ 4040// CODEGEN : file ../vk_helper.py line #912 4041 using namespace StreamControl; 4042 using namespace std; 4043 string final_str; 4044 string tmp_str; 4045 string extra_indent = " " + prefix; 4046 stringstream ss[10]; 4047 string stp_strs[3]; 4048// CODEGEN : file ../vk_helper.py line #1011 4049 if (pStruct->pNext) { 4050// CODEGEN : file ../vk_helper.py line #1015 4051 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4052 ss[0] << "0x" << &pStruct->pNext; 4053// CODEGEN : file ../vk_helper.py line #1027 4054 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4055 ss[0].str(""); 4056 } 4057 else 4058 stp_strs[0] = ""; 4059// CODEGEN : file ../vk_helper.py line #1037 4060 tmp_str = vk_print_vkstencilopstate(&pStruct->front, extra_indent); 4061 ss[1] << "0x" << &pStruct->front; 4062 stp_strs[1] = " " + prefix + "front (addr)\n" + tmp_str; 4063// CODEGEN : file ../vk_helper.py line #1042 4064 ss[1].str(""); 4065// CODEGEN : file ../vk_helper.py line #1037 4066 tmp_str = vk_print_vkstencilopstate(&pStruct->back, extra_indent); 4067 ss[2] << "0x" << &pStruct->back; 4068 stp_strs[2] = " " + prefix + "back (addr)\n" + tmp_str; 4069// CODEGEN : file ../vk_helper.py line #1042 4070 ss[2].str(""); 4071// CODEGEN : file ../vk_helper.py line #1069 4072 if (StreamControl::writeAddress) 4073 ss[0] << "0x" << pStruct->pNext; 4074 else 4075 ss[0].str("address"); 4076// CODEGEN : file ../vk_helper.py line #1085 4077 ss[1] << "0x" << pStruct->flags; 4078// CODEGEN : file ../vk_helper.py line #1063 4079 ss[2].str(pStruct->depthTestEnable ? "TRUE" : "FALSE"); 4080// CODEGEN : file ../vk_helper.py line #1063 4081 ss[3].str(pStruct->depthWriteEnable ? "TRUE" : "FALSE"); 4082// CODEGEN : file ../vk_helper.py line #1063 4083 ss[4].str(pStruct->depthBoundsTestEnable ? "TRUE" : "FALSE"); 4084// CODEGEN : file ../vk_helper.py line #1063 4085 ss[5].str(pStruct->stencilTestEnable ? "TRUE" : "FALSE"); 4086// CODEGEN : file ../vk_helper.py line #1054 4087 ss[6].str("addr"); 4088// CODEGEN : file ../vk_helper.py line #1054 4089 ss[7].str("addr"); 4090// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4091 ss[8] << pStruct->minDepthBounds; 4092// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4093 ss[9] << pStruct->maxDepthBounds; 4094// CODEGEN : file ../vk_helper.py line #1113 4095 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "depthTestEnable = " + ss[2].str() + "\n" + prefix + "depthWriteEnable = " + ss[3].str() + "\n" + prefix + "depthCompareOp = " + string_VkCompareOp(pStruct->depthCompareOp) + "\n" + prefix + "depthBoundsTestEnable = " + ss[4].str() + "\n" + prefix + "stencilTestEnable = " + ss[5].str() + "\n" + prefix + "front = " + ss[6].str() + "\n" + prefix + "back = " + ss[7].str() + "\n" + prefix + "minDepthBounds = " + ss[8].str() + "\n" + prefix + "maxDepthBounds = " + ss[9].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4096 return final_str; 4097} 4098// CODEGEN : file ../vk_helper.py line #906 4099std::string vk_print_vkpipelinedynamicstatecreateinfo(const VkPipelineDynamicStateCreateInfo* pStruct, const std::string prefix) 4100{ 4101// CODEGEN : file ../vk_helper.py line #912 4102 using namespace StreamControl; 4103 using namespace std; 4104 string final_str; 4105 string tmp_str; 4106 string extra_indent = " " + prefix; 4107 stringstream ss[4]; 4108 string stp_strs[2]; 4109// CODEGEN : file ../vk_helper.py line #1011 4110 if (pStruct->pNext) { 4111// CODEGEN : file ../vk_helper.py line #1015 4112 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4113 ss[0] << "0x" << &pStruct->pNext; 4114// CODEGEN : file ../vk_helper.py line #1027 4115 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4116 ss[0].str(""); 4117 } 4118 else 4119 stp_strs[0] = ""; 4120// CODEGEN : file ../vk_helper.py line #931 4121// CODEGEN : file ../vk_helper.py line #933 4122// CODEGEN : file ../vk_helper.py line #938 4123 stp_strs[1] = ""; 4124 stringstream index_ss; 4125 if (pStruct->pDynamicStates) { 4126 for (uint32_t i = 0; i < pStruct->dynamicStateCount; i++) { 4127 index_ss.str(""); 4128 index_ss << i; 4129// CODEGEN : file ../vk_helper.py line #973 4130 ss[1] << string_VkDynamicState(pStruct->pDynamicStates[i]); 4131 stp_strs[1] += " " + prefix + "pDynamicStates[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 4132// CODEGEN : file ../vk_helper.py line #999 4133 ss[1].str(""); 4134 } 4135 } 4136// CODEGEN : file ../vk_helper.py line #1069 4137 if (StreamControl::writeAddress) 4138 ss[0] << "0x" << pStruct->pNext; 4139 else 4140 ss[0].str("address"); 4141// CODEGEN : file ../vk_helper.py line #1085 4142 ss[1] << "0x" << pStruct->flags; 4143// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4144 ss[2] << pStruct->dynamicStateCount; 4145// CODEGEN : file ../vk_helper.py line #1099 4146 if (pStruct->pDynamicStates) 4147 ss[3] << "0x" << pStruct->pDynamicStates << " (See individual array values below)"; 4148 else 4149 ss[3].str("NULL"); 4150// CODEGEN : file ../vk_helper.py line #1113 4151 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "dynamicStateCount = " + ss[2].str() + "\n" + prefix + "pDynamicStates = " + ss[3].str() + "\n" + stp_strs[1] + stp_strs[0]; 4152 return final_str; 4153} 4154// CODEGEN : file ../vk_helper.py line #906 4155std::string vk_print_vkpipelineinputassemblystatecreateinfo(const VkPipelineInputAssemblyStateCreateInfo* pStruct, const std::string prefix) 4156{ 4157// CODEGEN : file ../vk_helper.py line #912 4158 using namespace StreamControl; 4159 using namespace std; 4160 string final_str; 4161 string tmp_str; 4162 string extra_indent = " " + prefix; 4163 stringstream ss[3]; 4164 string stp_strs[1]; 4165// CODEGEN : file ../vk_helper.py line #1011 4166 if (pStruct->pNext) { 4167// CODEGEN : file ../vk_helper.py line #1015 4168 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4169 ss[0] << "0x" << &pStruct->pNext; 4170// CODEGEN : file ../vk_helper.py line #1027 4171 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4172 ss[0].str(""); 4173 } 4174 else 4175 stp_strs[0] = ""; 4176// CODEGEN : file ../vk_helper.py line #1069 4177 if (StreamControl::writeAddress) 4178 ss[0] << "0x" << pStruct->pNext; 4179 else 4180 ss[0].str("address"); 4181// CODEGEN : file ../vk_helper.py line #1085 4182 ss[1] << "0x" << pStruct->flags; 4183// CODEGEN : file ../vk_helper.py line #1063 4184 ss[2].str(pStruct->primitiveRestartEnable ? "TRUE" : "FALSE"); 4185// CODEGEN : file ../vk_helper.py line #1113 4186 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "topology = " + string_VkPrimitiveTopology(pStruct->topology) + "\n" + prefix + "primitiveRestartEnable = " + ss[2].str() + "\n" + stp_strs[0]; 4187 return final_str; 4188} 4189// CODEGEN : file ../vk_helper.py line #906 4190std::string vk_print_vkpipelinelayoutcreateinfo(const VkPipelineLayoutCreateInfo* pStruct, const std::string prefix) 4191{ 4192// CODEGEN : file ../vk_helper.py line #912 4193 using namespace StreamControl; 4194 using namespace std; 4195 string final_str; 4196 string tmp_str; 4197 string extra_indent = " " + prefix; 4198 stringstream ss[6]; 4199 string stp_strs[3]; 4200// CODEGEN : file ../vk_helper.py line #1011 4201 if (pStruct->pNext) { 4202// CODEGEN : file ../vk_helper.py line #1015 4203 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4204 ss[0] << "0x" << &pStruct->pNext; 4205// CODEGEN : file ../vk_helper.py line #1027 4206 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4207 ss[0].str(""); 4208 } 4209 else 4210 stp_strs[0] = ""; 4211// CODEGEN : file ../vk_helper.py line #931 4212// CODEGEN : file ../vk_helper.py line #933 4213// CODEGEN : file ../vk_helper.py line #938 4214 stp_strs[1] = ""; 4215 stringstream index_ss; 4216 if (pStruct->pSetLayouts) { 4217 for (uint32_t i = 0; i < pStruct->setLayoutCount; i++) { 4218 index_ss.str(""); 4219 index_ss << i; 4220// CODEGEN : file ../vk_helper.py line #989 4221 ss[1] << "0x" << pStruct->pSetLayouts[i]; 4222 stp_strs[1] += " " + prefix + "pSetLayouts[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 4223// CODEGEN : file ../vk_helper.py line #999 4224 ss[1].str(""); 4225 } 4226 } 4227// CODEGEN : file ../vk_helper.py line #931 4228// CODEGEN : file ../vk_helper.py line #933 4229// CODEGEN : file ../vk_helper.py line #938 4230 stp_strs[2] = ""; 4231 if (pStruct->pPushConstantRanges) { 4232 for (uint32_t i = 0; i < pStruct->pushConstantRangeCount; i++) { 4233 index_ss.str(""); 4234 index_ss << i; 4235// CODEGEN : file ../vk_helper.py line #979 4236 ss[2] << "0x" << &pStruct->pPushConstantRanges[i]; 4237 tmp_str = vk_print_vkpushconstantrange(&pStruct->pPushConstantRanges[i], extra_indent); 4238// CODEGEN : file ../vk_helper.py line #983 4239 stp_strs[2] += " " + prefix + "pPushConstantRanges[" + index_ss.str() + "] (addr)\n" + tmp_str; 4240// CODEGEN : file ../vk_helper.py line #999 4241 ss[2].str(""); 4242 } 4243 } 4244// CODEGEN : file ../vk_helper.py line #1069 4245 if (StreamControl::writeAddress) 4246 ss[0] << "0x" << pStruct->pNext; 4247 else 4248 ss[0].str("address"); 4249// CODEGEN : file ../vk_helper.py line #1085 4250 ss[1] << "0x" << pStruct->flags; 4251// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4252 ss[2] << pStruct->setLayoutCount; 4253// CODEGEN : file ../vk_helper.py line #1060 4254 ss[3] << "0x" << (void*)pStruct->pSetLayouts; 4255// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4256 ss[4] << pStruct->pushConstantRangeCount; 4257// CODEGEN : file ../vk_helper.py line #1060 4258 ss[5] << "0x" << (void*)pStruct->pPushConstantRanges; 4259// CODEGEN : file ../vk_helper.py line #1113 4260 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "setLayoutCount = " + ss[2].str() + "\n" + prefix + "pSetLayouts = " + ss[3].str() + "\n" + prefix + "pushConstantRangeCount = " + ss[4].str() + "\n" + prefix + "pPushConstantRanges = " + ss[5].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4261 return final_str; 4262} 4263// CODEGEN : file ../vk_helper.py line #906 4264std::string vk_print_vkpipelinemultisamplestatecreateinfo(const VkPipelineMultisampleStateCreateInfo* pStruct, const std::string prefix) 4265{ 4266// CODEGEN : file ../vk_helper.py line #912 4267 using namespace StreamControl; 4268 using namespace std; 4269 string final_str; 4270 string tmp_str; 4271 string extra_indent = " " + prefix; 4272 stringstream ss[7]; 4273 string stp_strs[1]; 4274// CODEGEN : file ../vk_helper.py line #1011 4275 if (pStruct->pNext) { 4276// CODEGEN : file ../vk_helper.py line #1015 4277 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4278 ss[0] << "0x" << &pStruct->pNext; 4279// CODEGEN : file ../vk_helper.py line #1027 4280 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4281 ss[0].str(""); 4282 } 4283 else 4284 stp_strs[0] = ""; 4285// CODEGEN : file ../vk_helper.py line #1069 4286 if (StreamControl::writeAddress) 4287 ss[0] << "0x" << pStruct->pNext; 4288 else 4289 ss[0].str("address"); 4290// CODEGEN : file ../vk_helper.py line #1085 4291 ss[1] << "0x" << pStruct->flags; 4292// CODEGEN : file ../vk_helper.py line #1063 4293 ss[2].str(pStruct->sampleShadingEnable ? "TRUE" : "FALSE"); 4294// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4295 ss[3] << pStruct->minSampleShading; 4296// CODEGEN : file ../vk_helper.py line #1085 4297 ss[4] << "0x" << pStruct->pSampleMask; 4298// CODEGEN : file ../vk_helper.py line #1063 4299 ss[5].str(pStruct->alphaToCoverageEnable ? "TRUE" : "FALSE"); 4300// CODEGEN : file ../vk_helper.py line #1063 4301 ss[6].str(pStruct->alphaToOneEnable ? "TRUE" : "FALSE"); 4302// CODEGEN : file ../vk_helper.py line #1113 4303 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "rasterizationSamples = " + string_VkSampleCountFlagBits(pStruct->rasterizationSamples) + "\n" + prefix + "sampleShadingEnable = " + ss[2].str() + "\n" + prefix + "minSampleShading = " + ss[3].str() + "\n" + prefix + "pSampleMask = " + ss[4].str() + "\n" + prefix + "alphaToCoverageEnable = " + ss[5].str() + "\n" + prefix + "alphaToOneEnable = " + ss[6].str() + "\n" + stp_strs[0]; 4304 return final_str; 4305} 4306// CODEGEN : file ../vk_helper.py line #906 4307std::string vk_print_vkpipelinerasterizationstatecreateinfo(const VkPipelineRasterizationStateCreateInfo* pStruct, const std::string prefix) 4308{ 4309// CODEGEN : file ../vk_helper.py line #912 4310 using namespace StreamControl; 4311 using namespace std; 4312 string final_str; 4313 string tmp_str; 4314 string extra_indent = " " + prefix; 4315 stringstream ss[10]; 4316 string stp_strs[1]; 4317// CODEGEN : file ../vk_helper.py line #1011 4318 if (pStruct->pNext) { 4319// CODEGEN : file ../vk_helper.py line #1015 4320 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4321 ss[0] << "0x" << &pStruct->pNext; 4322// CODEGEN : file ../vk_helper.py line #1027 4323 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4324 ss[0].str(""); 4325 } 4326 else 4327 stp_strs[0] = ""; 4328// CODEGEN : file ../vk_helper.py line #1069 4329 if (StreamControl::writeAddress) 4330 ss[0] << "0x" << pStruct->pNext; 4331 else 4332 ss[0].str("address"); 4333// CODEGEN : file ../vk_helper.py line #1085 4334 ss[1] << "0x" << pStruct->flags; 4335// CODEGEN : file ../vk_helper.py line #1063 4336 ss[2].str(pStruct->depthClampEnable ? "TRUE" : "FALSE"); 4337// CODEGEN : file ../vk_helper.py line #1063 4338 ss[3].str(pStruct->rasterizerDiscardEnable ? "TRUE" : "FALSE"); 4339// CODEGEN : file ../vk_helper.py line #1085 4340 ss[4] << "0x" << pStruct->cullMode; 4341// CODEGEN : file ../vk_helper.py line #1063 4342 ss[5].str(pStruct->depthBiasEnable ? "TRUE" : "FALSE"); 4343// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4344 ss[6] << pStruct->depthBiasConstantFactor; 4345// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4346 ss[7] << pStruct->depthBiasClamp; 4347// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4348 ss[8] << pStruct->depthBiasSlopeFactor; 4349// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4350 ss[9] << pStruct->lineWidth; 4351// CODEGEN : file ../vk_helper.py line #1113 4352 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "depthClampEnable = " + ss[2].str() + "\n" + prefix + "rasterizerDiscardEnable = " + ss[3].str() + "\n" + prefix + "polygonMode = " + string_VkPolygonMode(pStruct->polygonMode) + "\n" + prefix + "cullMode = " + ss[4].str() + "\n" + prefix + "frontFace = " + string_VkFrontFace(pStruct->frontFace) + "\n" + prefix + "depthBiasEnable = " + ss[5].str() + "\n" + prefix + "depthBiasConstantFactor = " + ss[6].str() + "\n" + prefix + "depthBiasClamp = " + ss[7].str() + "\n" + prefix + "depthBiasSlopeFactor = " + ss[8].str() + "\n" + prefix + "lineWidth = " + ss[9].str() + "\n" + stp_strs[0]; 4353 return final_str; 4354} 4355// CODEGEN : file ../vk_helper.py line #906 4356std::string vk_print_vkpipelinerasterizationstaterasterizationorderamd(const VkPipelineRasterizationStateRasterizationOrderAMD* pStruct, const std::string prefix) 4357{ 4358// CODEGEN : file ../vk_helper.py line #912 4359 using namespace StreamControl; 4360 using namespace std; 4361 string final_str; 4362 string tmp_str; 4363 string extra_indent = " " + prefix; 4364 stringstream ss[1]; 4365 string stp_strs[1]; 4366// CODEGEN : file ../vk_helper.py line #1011 4367 if (pStruct->pNext) { 4368// CODEGEN : file ../vk_helper.py line #1015 4369 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4370 ss[0] << "0x" << &pStruct->pNext; 4371// CODEGEN : file ../vk_helper.py line #1027 4372 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4373 ss[0].str(""); 4374 } 4375 else 4376 stp_strs[0] = ""; 4377// CODEGEN : file ../vk_helper.py line #1069 4378 if (StreamControl::writeAddress) 4379 ss[0] << "0x" << pStruct->pNext; 4380 else 4381 ss[0].str("address"); 4382// CODEGEN : file ../vk_helper.py line #1113 4383 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "rasterizationOrder = " + string_VkRasterizationOrderAMD(pStruct->rasterizationOrder) + "\n" + stp_strs[0]; 4384 return final_str; 4385} 4386// CODEGEN : file ../vk_helper.py line #906 4387std::string vk_print_vkpipelineshaderstagecreateinfo(const VkPipelineShaderStageCreateInfo* pStruct, const std::string prefix) 4388{ 4389// CODEGEN : file ../vk_helper.py line #912 4390 using namespace StreamControl; 4391 using namespace std; 4392 string final_str; 4393 string tmp_str; 4394 string extra_indent = " " + prefix; 4395 stringstream ss[5]; 4396 string stp_strs[2]; 4397// CODEGEN : file ../vk_helper.py line #1011 4398 if (pStruct->pNext) { 4399// CODEGEN : file ../vk_helper.py line #1015 4400 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4401 ss[0] << "0x" << &pStruct->pNext; 4402// CODEGEN : file ../vk_helper.py line #1027 4403 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4404 ss[0].str(""); 4405 } 4406 else 4407 stp_strs[0] = ""; 4408// CODEGEN : file ../vk_helper.py line #1011 4409 if (pStruct->pSpecializationInfo) { 4410// CODEGEN : file ../vk_helper.py line #1023 4411 tmp_str = vk_print_vkspecializationinfo(pStruct->pSpecializationInfo, extra_indent); 4412 ss[1] << "0x" << &pStruct->pSpecializationInfo; 4413// CODEGEN : file ../vk_helper.py line #1027 4414 stp_strs[1] = " " + prefix + "pSpecializationInfo (addr)\n" + tmp_str; 4415 ss[1].str(""); 4416 } 4417 else 4418 stp_strs[1] = ""; 4419// CODEGEN : file ../vk_helper.py line #1069 4420 if (StreamControl::writeAddress) 4421 ss[0] << "0x" << pStruct->pNext; 4422 else 4423 ss[0].str("address"); 4424// CODEGEN : file ../vk_helper.py line #1085 4425 ss[1] << "0x" << pStruct->flags; 4426// CODEGEN : file ../vk_helper.py line #1085 4427 ss[2] << "0x" << pStruct->module; 4428// CODEGEN : file ../vk_helper.py line #1075 4429 if (pStruct->pName != NULL) { 4430 ss[3] << pStruct->pName; 4431 } else { 4432 ss[3] << ""; 4433 } 4434// CODEGEN : file ../vk_helper.py line #1085 4435 ss[4] << "0x" << pStruct->pSpecializationInfo; 4436// CODEGEN : file ../vk_helper.py line #1113 4437 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "stage = " + string_VkShaderStageFlagBits(pStruct->stage) + "\n" + prefix + "module = " + ss[2].str() + "\n" + prefix + "pName = " + ss[3].str() + "\n" + prefix + "pSpecializationInfo = " + ss[4].str() + "\n" + stp_strs[1] + stp_strs[0]; 4438 return final_str; 4439} 4440// CODEGEN : file ../vk_helper.py line #906 4441std::string vk_print_vkpipelinetessellationstatecreateinfo(const VkPipelineTessellationStateCreateInfo* pStruct, const std::string prefix) 4442{ 4443// CODEGEN : file ../vk_helper.py line #912 4444 using namespace StreamControl; 4445 using namespace std; 4446 string final_str; 4447 string tmp_str; 4448 string extra_indent = " " + prefix; 4449 stringstream ss[3]; 4450 string stp_strs[1]; 4451// CODEGEN : file ../vk_helper.py line #1011 4452 if (pStruct->pNext) { 4453// CODEGEN : file ../vk_helper.py line #1015 4454 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4455 ss[0] << "0x" << &pStruct->pNext; 4456// CODEGEN : file ../vk_helper.py line #1027 4457 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4458 ss[0].str(""); 4459 } 4460 else 4461 stp_strs[0] = ""; 4462// CODEGEN : file ../vk_helper.py line #1069 4463 if (StreamControl::writeAddress) 4464 ss[0] << "0x" << pStruct->pNext; 4465 else 4466 ss[0].str("address"); 4467// CODEGEN : file ../vk_helper.py line #1085 4468 ss[1] << "0x" << pStruct->flags; 4469// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4470 ss[2] << pStruct->patchControlPoints; 4471// CODEGEN : file ../vk_helper.py line #1113 4472 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "patchControlPoints = " + ss[2].str() + "\n" + stp_strs[0]; 4473 return final_str; 4474} 4475// CODEGEN : file ../vk_helper.py line #906 4476std::string vk_print_vkpipelinevertexinputstatecreateinfo(const VkPipelineVertexInputStateCreateInfo* pStruct, const std::string prefix) 4477{ 4478// CODEGEN : file ../vk_helper.py line #912 4479 using namespace StreamControl; 4480 using namespace std; 4481 string final_str; 4482 string tmp_str; 4483 string extra_indent = " " + prefix; 4484 stringstream ss[6]; 4485 string stp_strs[3]; 4486// CODEGEN : file ../vk_helper.py line #1011 4487 if (pStruct->pNext) { 4488// CODEGEN : file ../vk_helper.py line #1015 4489 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4490 ss[0] << "0x" << &pStruct->pNext; 4491// CODEGEN : file ../vk_helper.py line #1027 4492 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4493 ss[0].str(""); 4494 } 4495 else 4496 stp_strs[0] = ""; 4497// CODEGEN : file ../vk_helper.py line #931 4498// CODEGEN : file ../vk_helper.py line #933 4499// CODEGEN : file ../vk_helper.py line #938 4500 stp_strs[1] = ""; 4501 stringstream index_ss; 4502 if (pStruct->pVertexBindingDescriptions) { 4503 for (uint32_t i = 0; i < pStruct->vertexBindingDescriptionCount; i++) { 4504 index_ss.str(""); 4505 index_ss << i; 4506// CODEGEN : file ../vk_helper.py line #979 4507 ss[1] << "0x" << &pStruct->pVertexBindingDescriptions[i]; 4508 tmp_str = vk_print_vkvertexinputbindingdescription(&pStruct->pVertexBindingDescriptions[i], extra_indent); 4509// CODEGEN : file ../vk_helper.py line #983 4510 stp_strs[1] += " " + prefix + "pVertexBindingDescriptions[" + index_ss.str() + "] (addr)\n" + tmp_str; 4511// CODEGEN : file ../vk_helper.py line #999 4512 ss[1].str(""); 4513 } 4514 } 4515// CODEGEN : file ../vk_helper.py line #931 4516// CODEGEN : file ../vk_helper.py line #933 4517// CODEGEN : file ../vk_helper.py line #938 4518 stp_strs[2] = ""; 4519 if (pStruct->pVertexAttributeDescriptions) { 4520 for (uint32_t i = 0; i < pStruct->vertexAttributeDescriptionCount; i++) { 4521 index_ss.str(""); 4522 index_ss << i; 4523// CODEGEN : file ../vk_helper.py line #979 4524 ss[2] << "0x" << &pStruct->pVertexAttributeDescriptions[i]; 4525 tmp_str = vk_print_vkvertexinputattributedescription(&pStruct->pVertexAttributeDescriptions[i], extra_indent); 4526// CODEGEN : file ../vk_helper.py line #983 4527 stp_strs[2] += " " + prefix + "pVertexAttributeDescriptions[" + index_ss.str() + "] (addr)\n" + tmp_str; 4528// CODEGEN : file ../vk_helper.py line #999 4529 ss[2].str(""); 4530 } 4531 } 4532// CODEGEN : file ../vk_helper.py line #1069 4533 if (StreamControl::writeAddress) 4534 ss[0] << "0x" << pStruct->pNext; 4535 else 4536 ss[0].str("address"); 4537// CODEGEN : file ../vk_helper.py line #1085 4538 ss[1] << "0x" << pStruct->flags; 4539// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4540 ss[2] << pStruct->vertexBindingDescriptionCount; 4541// CODEGEN : file ../vk_helper.py line #1060 4542 ss[3] << "0x" << (void*)pStruct->pVertexBindingDescriptions; 4543// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4544 ss[4] << pStruct->vertexAttributeDescriptionCount; 4545// CODEGEN : file ../vk_helper.py line #1060 4546 ss[5] << "0x" << (void*)pStruct->pVertexAttributeDescriptions; 4547// CODEGEN : file ../vk_helper.py line #1113 4548 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "vertexBindingDescriptionCount = " + ss[2].str() + "\n" + prefix + "pVertexBindingDescriptions = " + ss[3].str() + "\n" + prefix + "vertexAttributeDescriptionCount = " + ss[4].str() + "\n" + prefix + "pVertexAttributeDescriptions = " + ss[5].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4549 return final_str; 4550} 4551// CODEGEN : file ../vk_helper.py line #906 4552std::string vk_print_vkpipelineviewportstatecreateinfo(const VkPipelineViewportStateCreateInfo* pStruct, const std::string prefix) 4553{ 4554// CODEGEN : file ../vk_helper.py line #912 4555 using namespace StreamControl; 4556 using namespace std; 4557 string final_str; 4558 string tmp_str; 4559 string extra_indent = " " + prefix; 4560 stringstream ss[6]; 4561 string stp_strs[3]; 4562// CODEGEN : file ../vk_helper.py line #1011 4563 if (pStruct->pNext) { 4564// CODEGEN : file ../vk_helper.py line #1015 4565 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4566 ss[0] << "0x" << &pStruct->pNext; 4567// CODEGEN : file ../vk_helper.py line #1027 4568 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4569 ss[0].str(""); 4570 } 4571 else 4572 stp_strs[0] = ""; 4573// CODEGEN : file ../vk_helper.py line #931 4574// CODEGEN : file ../vk_helper.py line #933 4575// CODEGEN : file ../vk_helper.py line #938 4576 stp_strs[1] = ""; 4577 stringstream index_ss; 4578 if (pStruct->pViewports) { 4579 for (uint32_t i = 0; i < pStruct->viewportCount; i++) { 4580 index_ss.str(""); 4581 index_ss << i; 4582// CODEGEN : file ../vk_helper.py line #979 4583 ss[1] << "0x" << &pStruct->pViewports[i]; 4584 tmp_str = vk_print_vkviewport(&pStruct->pViewports[i], extra_indent); 4585// CODEGEN : file ../vk_helper.py line #983 4586 stp_strs[1] += " " + prefix + "pViewports[" + index_ss.str() + "] (addr)\n" + tmp_str; 4587// CODEGEN : file ../vk_helper.py line #999 4588 ss[1].str(""); 4589 } 4590 } 4591// CODEGEN : file ../vk_helper.py line #931 4592// CODEGEN : file ../vk_helper.py line #933 4593// CODEGEN : file ../vk_helper.py line #938 4594 stp_strs[2] = ""; 4595 if (pStruct->pScissors) { 4596 for (uint32_t i = 0; i < pStruct->scissorCount; i++) { 4597 index_ss.str(""); 4598 index_ss << i; 4599// CODEGEN : file ../vk_helper.py line #979 4600 ss[2] << "0x" << &pStruct->pScissors[i]; 4601 tmp_str = vk_print_vkrect2d(&pStruct->pScissors[i], extra_indent); 4602// CODEGEN : file ../vk_helper.py line #983 4603 stp_strs[2] += " " + prefix + "pScissors[" + index_ss.str() + "] (addr)\n" + tmp_str; 4604// CODEGEN : file ../vk_helper.py line #999 4605 ss[2].str(""); 4606 } 4607 } 4608// CODEGEN : file ../vk_helper.py line #1069 4609 if (StreamControl::writeAddress) 4610 ss[0] << "0x" << pStruct->pNext; 4611 else 4612 ss[0].str("address"); 4613// CODEGEN : file ../vk_helper.py line #1085 4614 ss[1] << "0x" << pStruct->flags; 4615// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4616 ss[2] << pStruct->viewportCount; 4617// CODEGEN : file ../vk_helper.py line #1060 4618 ss[3] << "0x" << (void*)pStruct->pViewports; 4619// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4620 ss[4] << pStruct->scissorCount; 4621// CODEGEN : file ../vk_helper.py line #1060 4622 ss[5] << "0x" << (void*)pStruct->pScissors; 4623// CODEGEN : file ../vk_helper.py line #1113 4624 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "viewportCount = " + ss[2].str() + "\n" + prefix + "pViewports = " + ss[3].str() + "\n" + prefix + "scissorCount = " + ss[4].str() + "\n" + prefix + "pScissors = " + ss[5].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4625 return final_str; 4626} 4627// CODEGEN : file ../vk_helper.py line #906 4628std::string vk_print_vkpresentinfokhr(const VkPresentInfoKHR* pStruct, const std::string prefix) 4629{ 4630// CODEGEN : file ../vk_helper.py line #912 4631 using namespace StreamControl; 4632 using namespace std; 4633 string final_str; 4634 string tmp_str; 4635 string extra_indent = " " + prefix; 4636 stringstream ss[7]; 4637 string stp_strs[4]; 4638// CODEGEN : file ../vk_helper.py line #1011 4639 if (pStruct->pNext) { 4640// CODEGEN : file ../vk_helper.py line #1015 4641 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4642 ss[0] << "0x" << &pStruct->pNext; 4643// CODEGEN : file ../vk_helper.py line #1027 4644 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4645 ss[0].str(""); 4646 } 4647 else 4648 stp_strs[0] = ""; 4649// CODEGEN : file ../vk_helper.py line #931 4650// CODEGEN : file ../vk_helper.py line #933 4651// CODEGEN : file ../vk_helper.py line #938 4652 stp_strs[1] = ""; 4653 stringstream index_ss; 4654 if (pStruct->pWaitSemaphores) { 4655 for (uint32_t i = 0; i < pStruct->waitSemaphoreCount; i++) { 4656 index_ss.str(""); 4657 index_ss << i; 4658// CODEGEN : file ../vk_helper.py line #989 4659 ss[1] << "0x" << pStruct->pWaitSemaphores[i]; 4660 stp_strs[1] += " " + prefix + "pWaitSemaphores[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 4661// CODEGEN : file ../vk_helper.py line #999 4662 ss[1].str(""); 4663 } 4664 } 4665// CODEGEN : file ../vk_helper.py line #931 4666// CODEGEN : file ../vk_helper.py line #933 4667// CODEGEN : file ../vk_helper.py line #938 4668 stp_strs[2] = ""; 4669 if (pStruct->pSwapchains) { 4670 for (uint32_t i = 0; i < pStruct->swapchainCount; i++) { 4671 index_ss.str(""); 4672 index_ss << i; 4673// CODEGEN : file ../vk_helper.py line #989 4674 ss[2] << "0x" << pStruct->pSwapchains[i]; 4675 stp_strs[2] += " " + prefix + "pSwapchains[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 4676// CODEGEN : file ../vk_helper.py line #999 4677 ss[2].str(""); 4678 } 4679 } 4680// CODEGEN : file ../vk_helper.py line #931 4681// CODEGEN : file ../vk_helper.py line #933 4682// CODEGEN : file ../vk_helper.py line #938 4683 stp_strs[3] = ""; 4684 if (pStruct->pImageIndices) { 4685 for (uint32_t i = 0; i < pStruct->swapchainCount; i++) { 4686 index_ss.str(""); 4687 index_ss << i; 4688// CODEGEN : file ../vk_helper.py line #989 4689 ss[3] << "0x" << pStruct->pImageIndices[i]; 4690 stp_strs[3] += " " + prefix + "pImageIndices[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 4691// CODEGEN : file ../vk_helper.py line #999 4692 ss[3].str(""); 4693 } 4694 } 4695// CODEGEN : file ../vk_helper.py line #1069 4696 if (StreamControl::writeAddress) 4697 ss[0] << "0x" << pStruct->pNext; 4698 else 4699 ss[0].str("address"); 4700// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4701 ss[1] << pStruct->waitSemaphoreCount; 4702// CODEGEN : file ../vk_helper.py line #1060 4703 ss[2] << "0x" << (void*)pStruct->pWaitSemaphores; 4704// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4705 ss[3] << pStruct->swapchainCount; 4706// CODEGEN : file ../vk_helper.py line #1060 4707 ss[4] << "0x" << (void*)pStruct->pSwapchains; 4708// CODEGEN : file ../vk_helper.py line #1060 4709 ss[5] << "0x" << (void*)pStruct->pImageIndices; 4710// CODEGEN : file ../vk_helper.py line #1099 4711 if (pStruct->pResults) 4712 ss[6] << "0x" << pStruct->pResults << " (See individual array values below)"; 4713 else 4714 ss[6].str("NULL"); 4715// CODEGEN : file ../vk_helper.py line #1113 4716 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "waitSemaphoreCount = " + ss[1].str() + "\n" + prefix + "pWaitSemaphores = " + ss[2].str() + "\n" + prefix + "swapchainCount = " + ss[3].str() + "\n" + prefix + "pSwapchains = " + ss[4].str() + "\n" + prefix + "pImageIndices = " + ss[5].str() + "\n" + prefix + "pResults = " + ss[6].str() + "\n" + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4717 return final_str; 4718} 4719// CODEGEN : file ../vk_helper.py line #906 4720std::string vk_print_vkpushconstantrange(const VkPushConstantRange* pStruct, const std::string prefix) 4721{ 4722// CODEGEN : file ../vk_helper.py line #912 4723 using namespace StreamControl; 4724 using namespace std; 4725 string final_str; 4726 string tmp_str; 4727 string extra_indent = " " + prefix; 4728 stringstream ss[3]; 4729// CODEGEN : file ../vk_helper.py line #1085 4730 ss[0] << "0x" << pStruct->stageFlags; 4731// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 4732 ss[1] << "0x" << pStruct->offset; 4733// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4734 ss[2] << pStruct->size; 4735// CODEGEN : file ../vk_helper.py line #1113 4736 final_str = prefix + "stageFlags = " + ss[0].str() + "\n" + prefix + "offset = " + ss[1].str() + "\n" + prefix + "size = " + ss[2].str() + "\n"; 4737 return final_str; 4738} 4739// CODEGEN : file ../vk_helper.py line #906 4740std::string vk_print_vkquerypoolcreateinfo(const VkQueryPoolCreateInfo* pStruct, const std::string prefix) 4741{ 4742// CODEGEN : file ../vk_helper.py line #912 4743 using namespace StreamControl; 4744 using namespace std; 4745 string final_str; 4746 string tmp_str; 4747 string extra_indent = " " + prefix; 4748 stringstream ss[4]; 4749 string stp_strs[1]; 4750// CODEGEN : file ../vk_helper.py line #1011 4751 if (pStruct->pNext) { 4752// CODEGEN : file ../vk_helper.py line #1015 4753 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4754 ss[0] << "0x" << &pStruct->pNext; 4755// CODEGEN : file ../vk_helper.py line #1027 4756 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4757 ss[0].str(""); 4758 } 4759 else 4760 stp_strs[0] = ""; 4761// CODEGEN : file ../vk_helper.py line #1069 4762 if (StreamControl::writeAddress) 4763 ss[0] << "0x" << pStruct->pNext; 4764 else 4765 ss[0].str("address"); 4766// CODEGEN : file ../vk_helper.py line #1085 4767 ss[1] << "0x" << pStruct->flags; 4768// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4769 ss[2] << pStruct->queryCount; 4770// CODEGEN : file ../vk_helper.py line #1085 4771 ss[3] << "0x" << pStruct->pipelineStatistics; 4772// CODEGEN : file ../vk_helper.py line #1113 4773 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "queryType = " + string_VkQueryType(pStruct->queryType) + "\n" + prefix + "queryCount = " + ss[2].str() + "\n" + prefix + "pipelineStatistics = " + ss[3].str() + "\n" + stp_strs[0]; 4774 return final_str; 4775} 4776// CODEGEN : file ../vk_helper.py line #906 4777std::string vk_print_vkqueuefamilyproperties(const VkQueueFamilyProperties* pStruct, const std::string prefix) 4778{ 4779// CODEGEN : file ../vk_helper.py line #912 4780 using namespace StreamControl; 4781 using namespace std; 4782 string final_str; 4783 string tmp_str; 4784 string extra_indent = " " + prefix; 4785 stringstream ss[4]; 4786 string stp_strs[1]; 4787// CODEGEN : file ../vk_helper.py line #1037 4788 tmp_str = vk_print_vkextent3d(&pStruct->minImageTransferGranularity, extra_indent); 4789 ss[0] << "0x" << &pStruct->minImageTransferGranularity; 4790 stp_strs[0] = " " + prefix + "minImageTransferGranularity (addr)\n" + tmp_str; 4791// CODEGEN : file ../vk_helper.py line #1042 4792 ss[0].str(""); 4793// CODEGEN : file ../vk_helper.py line #1085 4794 ss[0] << "0x" << pStruct->queueFlags; 4795// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4796 ss[1] << pStruct->queueCount; 4797// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 4798 ss[2] << "0x" << pStruct->timestampValidBits; 4799// CODEGEN : file ../vk_helper.py line #1054 4800 ss[3].str("addr"); 4801// CODEGEN : file ../vk_helper.py line #1113 4802 final_str = prefix + "queueFlags = " + ss[0].str() + "\n" + prefix + "queueCount = " + ss[1].str() + "\n" + prefix + "timestampValidBits = " + ss[2].str() + "\n" + prefix + "minImageTransferGranularity = " + ss[3].str() + "\n" + stp_strs[0]; 4803 return final_str; 4804} 4805// CODEGEN : file ../vk_helper.py line #906 4806std::string vk_print_vkrect2d(const VkRect2D* pStruct, const std::string prefix) 4807{ 4808// CODEGEN : file ../vk_helper.py line #912 4809 using namespace StreamControl; 4810 using namespace std; 4811 string final_str; 4812 string tmp_str; 4813 string extra_indent = " " + prefix; 4814 stringstream ss[2]; 4815 string stp_strs[2]; 4816// CODEGEN : file ../vk_helper.py line #1037 4817 tmp_str = vk_print_vkoffset2d(&pStruct->offset, extra_indent); 4818 ss[0] << "0x" << &pStruct->offset; 4819 stp_strs[0] = " " + prefix + "offset (addr)\n" + tmp_str; 4820// CODEGEN : file ../vk_helper.py line #1042 4821 ss[0].str(""); 4822// CODEGEN : file ../vk_helper.py line #1037 4823 tmp_str = vk_print_vkextent2d(&pStruct->extent, extra_indent); 4824 ss[1] << "0x" << &pStruct->extent; 4825 stp_strs[1] = " " + prefix + "extent (addr)\n" + tmp_str; 4826// CODEGEN : file ../vk_helper.py line #1042 4827 ss[1].str(""); 4828// CODEGEN : file ../vk_helper.py line #1054 4829 ss[0].str("addr"); 4830// CODEGEN : file ../vk_helper.py line #1054 4831 ss[1].str("addr"); 4832// CODEGEN : file ../vk_helper.py line #1113 4833 final_str = prefix + "offset = " + ss[0].str() + "\n" + prefix + "extent = " + ss[1].str() + "\n" + stp_strs[1] + stp_strs[0]; 4834 return final_str; 4835} 4836// CODEGEN : file ../vk_helper.py line #906 4837std::string vk_print_vkrenderpassbegininfo(const VkRenderPassBeginInfo* pStruct, const std::string prefix) 4838{ 4839// CODEGEN : file ../vk_helper.py line #912 4840 using namespace StreamControl; 4841 using namespace std; 4842 string final_str; 4843 string tmp_str; 4844 string extra_indent = " " + prefix; 4845 stringstream ss[6]; 4846 string stp_strs[3]; 4847// CODEGEN : file ../vk_helper.py line #1011 4848 if (pStruct->pNext) { 4849// CODEGEN : file ../vk_helper.py line #1015 4850 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4851 ss[0] << "0x" << &pStruct->pNext; 4852// CODEGEN : file ../vk_helper.py line #1027 4853 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4854 ss[0].str(""); 4855 } 4856 else 4857 stp_strs[0] = ""; 4858// CODEGEN : file ../vk_helper.py line #1037 4859 tmp_str = vk_print_vkrect2d(&pStruct->renderArea, extra_indent); 4860 ss[1] << "0x" << &pStruct->renderArea; 4861 stp_strs[1] = " " + prefix + "renderArea (addr)\n" + tmp_str; 4862// CODEGEN : file ../vk_helper.py line #1042 4863 ss[1].str(""); 4864// CODEGEN : file ../vk_helper.py line #931 4865// CODEGEN : file ../vk_helper.py line #933 4866// CODEGEN : file ../vk_helper.py line #938 4867 stp_strs[2] = ""; 4868 stringstream index_ss; 4869 if (pStruct->pClearValues) { 4870 for (uint32_t i = 0; i < pStruct->clearValueCount; i++) { 4871 index_ss.str(""); 4872 index_ss << i; 4873// CODEGEN : file ../vk_helper.py line #979 4874 ss[2] << "0x" << &pStruct->pClearValues[i]; 4875 tmp_str = vk_print_vkclearvalue(&pStruct->pClearValues[i], extra_indent); 4876// CODEGEN : file ../vk_helper.py line #983 4877 stp_strs[2] += " " + prefix + "pClearValues[" + index_ss.str() + "] (addr)\n" + tmp_str; 4878// CODEGEN : file ../vk_helper.py line #999 4879 ss[2].str(""); 4880 } 4881 } 4882// CODEGEN : file ../vk_helper.py line #1069 4883 if (StreamControl::writeAddress) 4884 ss[0] << "0x" << pStruct->pNext; 4885 else 4886 ss[0].str("address"); 4887// CODEGEN : file ../vk_helper.py line #1085 4888 ss[1] << "0x" << pStruct->renderPass; 4889// CODEGEN : file ../vk_helper.py line #1085 4890 ss[2] << "0x" << pStruct->framebuffer; 4891// CODEGEN : file ../vk_helper.py line #1054 4892 ss[3].str("addr"); 4893// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4894 ss[4] << pStruct->clearValueCount; 4895// CODEGEN : file ../vk_helper.py line #1060 4896 ss[5] << "0x" << (void*)pStruct->pClearValues; 4897// CODEGEN : file ../vk_helper.py line #1113 4898 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "renderPass = " + ss[1].str() + "\n" + prefix + "framebuffer = " + ss[2].str() + "\n" + prefix + "renderArea = " + ss[3].str() + "\n" + prefix + "clearValueCount = " + ss[4].str() + "\n" + prefix + "pClearValues = " + ss[5].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4899 return final_str; 4900} 4901// CODEGEN : file ../vk_helper.py line #906 4902std::string vk_print_vkrenderpasscreateinfo(const VkRenderPassCreateInfo* pStruct, const std::string prefix) 4903{ 4904// CODEGEN : file ../vk_helper.py line #912 4905 using namespace StreamControl; 4906 using namespace std; 4907 string final_str; 4908 string tmp_str; 4909 string extra_indent = " " + prefix; 4910 stringstream ss[8]; 4911 string stp_strs[4]; 4912// CODEGEN : file ../vk_helper.py line #1011 4913 if (pStruct->pNext) { 4914// CODEGEN : file ../vk_helper.py line #1015 4915 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4916 ss[0] << "0x" << &pStruct->pNext; 4917// CODEGEN : file ../vk_helper.py line #1027 4918 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4919 ss[0].str(""); 4920 } 4921 else 4922 stp_strs[0] = ""; 4923// CODEGEN : file ../vk_helper.py line #931 4924// CODEGEN : file ../vk_helper.py line #933 4925// CODEGEN : file ../vk_helper.py line #938 4926 stp_strs[1] = ""; 4927 stringstream index_ss; 4928 if (pStruct->pAttachments) { 4929 for (uint32_t i = 0; i < pStruct->attachmentCount; i++) { 4930 index_ss.str(""); 4931 index_ss << i; 4932// CODEGEN : file ../vk_helper.py line #979 4933 ss[1] << "0x" << &pStruct->pAttachments[i]; 4934 tmp_str = vk_print_vkattachmentdescription(&pStruct->pAttachments[i], extra_indent); 4935// CODEGEN : file ../vk_helper.py line #983 4936 stp_strs[1] += " " + prefix + "pAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 4937// CODEGEN : file ../vk_helper.py line #999 4938 ss[1].str(""); 4939 } 4940 } 4941// CODEGEN : file ../vk_helper.py line #931 4942// CODEGEN : file ../vk_helper.py line #933 4943// CODEGEN : file ../vk_helper.py line #938 4944 stp_strs[2] = ""; 4945 if (pStruct->pSubpasses) { 4946 for (uint32_t i = 0; i < pStruct->subpassCount; i++) { 4947 index_ss.str(""); 4948 index_ss << i; 4949// CODEGEN : file ../vk_helper.py line #979 4950 ss[2] << "0x" << &pStruct->pSubpasses[i]; 4951 tmp_str = vk_print_vksubpassdescription(&pStruct->pSubpasses[i], extra_indent); 4952// CODEGEN : file ../vk_helper.py line #983 4953 stp_strs[2] += " " + prefix + "pSubpasses[" + index_ss.str() + "] (addr)\n" + tmp_str; 4954// CODEGEN : file ../vk_helper.py line #999 4955 ss[2].str(""); 4956 } 4957 } 4958// CODEGEN : file ../vk_helper.py line #931 4959// CODEGEN : file ../vk_helper.py line #933 4960// CODEGEN : file ../vk_helper.py line #938 4961 stp_strs[3] = ""; 4962 if (pStruct->pDependencies) { 4963 for (uint32_t i = 0; i < pStruct->dependencyCount; i++) { 4964 index_ss.str(""); 4965 index_ss << i; 4966// CODEGEN : file ../vk_helper.py line #979 4967 ss[3] << "0x" << &pStruct->pDependencies[i]; 4968 tmp_str = vk_print_vksubpassdependency(&pStruct->pDependencies[i], extra_indent); 4969// CODEGEN : file ../vk_helper.py line #983 4970 stp_strs[3] += " " + prefix + "pDependencies[" + index_ss.str() + "] (addr)\n" + tmp_str; 4971// CODEGEN : file ../vk_helper.py line #999 4972 ss[3].str(""); 4973 } 4974 } 4975// CODEGEN : file ../vk_helper.py line #1069 4976 if (StreamControl::writeAddress) 4977 ss[0] << "0x" << pStruct->pNext; 4978 else 4979 ss[0].str("address"); 4980// CODEGEN : file ../vk_helper.py line #1085 4981 ss[1] << "0x" << pStruct->flags; 4982// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4983 ss[2] << pStruct->attachmentCount; 4984// CODEGEN : file ../vk_helper.py line #1060 4985 ss[3] << "0x" << (void*)pStruct->pAttachments; 4986// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4987 ss[4] << pStruct->subpassCount; 4988// CODEGEN : file ../vk_helper.py line #1060 4989 ss[5] << "0x" << (void*)pStruct->pSubpasses; 4990// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 4991 ss[6] << pStruct->dependencyCount; 4992// CODEGEN : file ../vk_helper.py line #1060 4993 ss[7] << "0x" << (void*)pStruct->pDependencies; 4994// CODEGEN : file ../vk_helper.py line #1113 4995 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "attachmentCount = " + ss[2].str() + "\n" + prefix + "pAttachments = " + ss[3].str() + "\n" + prefix + "subpassCount = " + ss[4].str() + "\n" + prefix + "pSubpasses = " + ss[5].str() + "\n" + prefix + "dependencyCount = " + ss[6].str() + "\n" + prefix + "pDependencies = " + ss[7].str() + "\n" + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4996 return final_str; 4997} 4998// CODEGEN : file ../vk_helper.py line #906 4999std::string vk_print_vksamplercreateinfo(const VkSamplerCreateInfo* pStruct, const std::string prefix) 5000{ 5001// CODEGEN : file ../vk_helper.py line #912 5002 using namespace StreamControl; 5003 using namespace std; 5004 string final_str; 5005 string tmp_str; 5006 string extra_indent = " " + prefix; 5007 stringstream ss[9]; 5008 string stp_strs[1]; 5009// CODEGEN : file ../vk_helper.py line #1011 5010 if (pStruct->pNext) { 5011// CODEGEN : file ../vk_helper.py line #1015 5012 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5013 ss[0] << "0x" << &pStruct->pNext; 5014// CODEGEN : file ../vk_helper.py line #1027 5015 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5016 ss[0].str(""); 5017 } 5018 else 5019 stp_strs[0] = ""; 5020// CODEGEN : file ../vk_helper.py line #1069 5021 if (StreamControl::writeAddress) 5022 ss[0] << "0x" << pStruct->pNext; 5023 else 5024 ss[0].str("address"); 5025// CODEGEN : file ../vk_helper.py line #1085 5026 ss[1] << "0x" << pStruct->flags; 5027// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5028 ss[2] << pStruct->mipLodBias; 5029// CODEGEN : file ../vk_helper.py line #1063 5030 ss[3].str(pStruct->anisotropyEnable ? "TRUE" : "FALSE"); 5031// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5032 ss[4] << pStruct->maxAnisotropy; 5033// CODEGEN : file ../vk_helper.py line #1063 5034 ss[5].str(pStruct->compareEnable ? "TRUE" : "FALSE"); 5035// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5036 ss[6] << pStruct->minLod; 5037// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5038 ss[7] << pStruct->maxLod; 5039// CODEGEN : file ../vk_helper.py line #1063 5040 ss[8].str(pStruct->unnormalizedCoordinates ? "TRUE" : "FALSE"); 5041// CODEGEN : file ../vk_helper.py line #1113 5042 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "magFilter = " + string_VkFilter(pStruct->magFilter) + "\n" + prefix + "minFilter = " + string_VkFilter(pStruct->minFilter) + "\n" + prefix + "mipmapMode = " + string_VkSamplerMipmapMode(pStruct->mipmapMode) + "\n" + prefix + "addressModeU = " + string_VkSamplerAddressMode(pStruct->addressModeU) + "\n" + prefix + "addressModeV = " + string_VkSamplerAddressMode(pStruct->addressModeV) + "\n" + prefix + "addressModeW = " + string_VkSamplerAddressMode(pStruct->addressModeW) + "\n" + prefix + "mipLodBias = " + ss[2].str() + "\n" + prefix + "anisotropyEnable = " + ss[3].str() + "\n" + prefix + "maxAnisotropy = " + ss[4].str() + "\n" + prefix + "compareEnable = " + ss[5].str() + "\n" + prefix + "compareOp = " + string_VkCompareOp(pStruct->compareOp) + "\n" + prefix + "minLod = " + ss[6].str() + "\n" + prefix + "maxLod = " + ss[7].str() + "\n" + prefix + "borderColor = " + string_VkBorderColor(pStruct->borderColor) + "\n" + prefix + "unnormalizedCoordinates = " + ss[8].str() + "\n" + stp_strs[0]; 5043 return final_str; 5044} 5045// CODEGEN : file ../vk_helper.py line #906 5046std::string vk_print_vksemaphorecreateinfo(const VkSemaphoreCreateInfo* pStruct, const std::string prefix) 5047{ 5048// CODEGEN : file ../vk_helper.py line #912 5049 using namespace StreamControl; 5050 using namespace std; 5051 string final_str; 5052 string tmp_str; 5053 string extra_indent = " " + prefix; 5054 stringstream ss[2]; 5055 string stp_strs[1]; 5056// CODEGEN : file ../vk_helper.py line #1011 5057 if (pStruct->pNext) { 5058// CODEGEN : file ../vk_helper.py line #1015 5059 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5060 ss[0] << "0x" << &pStruct->pNext; 5061// CODEGEN : file ../vk_helper.py line #1027 5062 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5063 ss[0].str(""); 5064 } 5065 else 5066 stp_strs[0] = ""; 5067// CODEGEN : file ../vk_helper.py line #1069 5068 if (StreamControl::writeAddress) 5069 ss[0] << "0x" << pStruct->pNext; 5070 else 5071 ss[0].str("address"); 5072// CODEGEN : file ../vk_helper.py line #1085 5073 ss[1] << "0x" << pStruct->flags; 5074// CODEGEN : file ../vk_helper.py line #1113 5075 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + stp_strs[0]; 5076 return final_str; 5077} 5078// CODEGEN : file ../vk_helper.py line #906 5079std::string vk_print_vkshadermodulecreateinfo(const VkShaderModuleCreateInfo* pStruct, const std::string prefix) 5080{ 5081// CODEGEN : file ../vk_helper.py line #912 5082 using namespace StreamControl; 5083 using namespace std; 5084 string final_str; 5085 string tmp_str; 5086 string extra_indent = " " + prefix; 5087 stringstream ss[4]; 5088 string stp_strs[1]; 5089// CODEGEN : file ../vk_helper.py line #1011 5090 if (pStruct->pNext) { 5091// CODEGEN : file ../vk_helper.py line #1015 5092 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5093 ss[0] << "0x" << &pStruct->pNext; 5094// CODEGEN : file ../vk_helper.py line #1027 5095 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5096 ss[0].str(""); 5097 } 5098 else 5099 stp_strs[0] = ""; 5100// CODEGEN : file ../vk_helper.py line #1069 5101 if (StreamControl::writeAddress) 5102 ss[0] << "0x" << pStruct->pNext; 5103 else 5104 ss[0].str("address"); 5105// CODEGEN : file ../vk_helper.py line #1085 5106 ss[1] << "0x" << pStruct->flags; 5107// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5108 ss[2] << pStruct->codeSize; 5109// CODEGEN : file ../vk_helper.py line #1085 5110 ss[3] << "0x" << pStruct->pCode; 5111// CODEGEN : file ../vk_helper.py line #1113 5112 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "codeSize = " + ss[2].str() + "\n" + prefix + "pCode = " + ss[3].str() + "\n" + stp_strs[0]; 5113 return final_str; 5114} 5115// CODEGEN : file ../vk_helper.py line #906 5116std::string vk_print_vksparsebuffermemorybindinfo(const VkSparseBufferMemoryBindInfo* pStruct, const std::string prefix) 5117{ 5118// CODEGEN : file ../vk_helper.py line #912 5119 using namespace StreamControl; 5120 using namespace std; 5121 string final_str; 5122 string tmp_str; 5123 string extra_indent = " " + prefix; 5124 stringstream ss[3]; 5125 string stp_strs[1]; 5126// CODEGEN : file ../vk_helper.py line #931 5127// CODEGEN : file ../vk_helper.py line #933 5128// CODEGEN : file ../vk_helper.py line #938 5129 stp_strs[0] = ""; 5130 stringstream index_ss; 5131 if (pStruct->pBinds) { 5132 for (uint32_t i = 0; i < pStruct->bindCount; i++) { 5133 index_ss.str(""); 5134 index_ss << i; 5135// CODEGEN : file ../vk_helper.py line #979 5136 ss[0] << "0x" << &pStruct->pBinds[i]; 5137 tmp_str = vk_print_vksparsememorybind(&pStruct->pBinds[i], extra_indent); 5138// CODEGEN : file ../vk_helper.py line #983 5139 stp_strs[0] += " " + prefix + "pBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 5140// CODEGEN : file ../vk_helper.py line #999 5141 ss[0].str(""); 5142 } 5143 } 5144// CODEGEN : file ../vk_helper.py line #1085 5145 ss[0] << "0x" << pStruct->buffer; 5146// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5147 ss[1] << pStruct->bindCount; 5148// CODEGEN : file ../vk_helper.py line #1060 5149 ss[2] << "0x" << (void*)pStruct->pBinds; 5150// CODEGEN : file ../vk_helper.py line #1113 5151 final_str = prefix + "buffer = " + ss[0].str() + "\n" + prefix + "bindCount = " + ss[1].str() + "\n" + prefix + "pBinds = " + ss[2].str() + "\n" + stp_strs[0]; 5152 return final_str; 5153} 5154// CODEGEN : file ../vk_helper.py line #906 5155std::string vk_print_vksparseimageformatproperties(const VkSparseImageFormatProperties* pStruct, const std::string prefix) 5156{ 5157// CODEGEN : file ../vk_helper.py line #912 5158 using namespace StreamControl; 5159 using namespace std; 5160 string final_str; 5161 string tmp_str; 5162 string extra_indent = " " + prefix; 5163 stringstream ss[3]; 5164 string stp_strs[1]; 5165// CODEGEN : file ../vk_helper.py line #1037 5166 tmp_str = vk_print_vkextent3d(&pStruct->imageGranularity, extra_indent); 5167 ss[0] << "0x" << &pStruct->imageGranularity; 5168 stp_strs[0] = " " + prefix + "imageGranularity (addr)\n" + tmp_str; 5169// CODEGEN : file ../vk_helper.py line #1042 5170 ss[0].str(""); 5171// CODEGEN : file ../vk_helper.py line #1085 5172 ss[0] << "0x" << pStruct->aspectMask; 5173// CODEGEN : file ../vk_helper.py line #1054 5174 ss[1].str("addr"); 5175// CODEGEN : file ../vk_helper.py line #1085 5176 ss[2] << "0x" << pStruct->flags; 5177// CODEGEN : file ../vk_helper.py line #1113 5178 final_str = prefix + "aspectMask = " + ss[0].str() + "\n" + prefix + "imageGranularity = " + ss[1].str() + "\n" + prefix + "flags = " + ss[2].str() + "\n" + stp_strs[0]; 5179 return final_str; 5180} 5181// CODEGEN : file ../vk_helper.py line #906 5182std::string vk_print_vksparseimagememorybind(const VkSparseImageMemoryBind* pStruct, const std::string prefix) 5183{ 5184// CODEGEN : file ../vk_helper.py line #912 5185 using namespace StreamControl; 5186 using namespace std; 5187 string final_str; 5188 string tmp_str; 5189 string extra_indent = " " + prefix; 5190 stringstream ss[6]; 5191 string stp_strs[3]; 5192// CODEGEN : file ../vk_helper.py line #1037 5193 tmp_str = vk_print_vkimagesubresource(&pStruct->subresource, extra_indent); 5194 ss[0] << "0x" << &pStruct->subresource; 5195 stp_strs[0] = " " + prefix + "subresource (addr)\n" + tmp_str; 5196// CODEGEN : file ../vk_helper.py line #1042 5197 ss[0].str(""); 5198// CODEGEN : file ../vk_helper.py line #1037 5199 tmp_str = vk_print_vkoffset3d(&pStruct->offset, extra_indent); 5200 ss[1] << "0x" << &pStruct->offset; 5201 stp_strs[1] = " " + prefix + "offset (addr)\n" + tmp_str; 5202// CODEGEN : file ../vk_helper.py line #1042 5203 ss[1].str(""); 5204// CODEGEN : file ../vk_helper.py line #1037 5205 tmp_str = vk_print_vkextent3d(&pStruct->extent, extra_indent); 5206 ss[2] << "0x" << &pStruct->extent; 5207 stp_strs[2] = " " + prefix + "extent (addr)\n" + tmp_str; 5208// CODEGEN : file ../vk_helper.py line #1042 5209 ss[2].str(""); 5210// CODEGEN : file ../vk_helper.py line #1054 5211 ss[0].str("addr"); 5212// CODEGEN : file ../vk_helper.py line #1054 5213 ss[1].str("addr"); 5214// CODEGEN : file ../vk_helper.py line #1054 5215 ss[2].str("addr"); 5216// CODEGEN : file ../vk_helper.py line #1085 5217 ss[3] << "0x" << pStruct->memory; 5218// CODEGEN : file ../vk_helper.py line #1085 5219 ss[4] << "0x" << pStruct->memoryOffset; 5220// CODEGEN : file ../vk_helper.py line #1085 5221 ss[5] << "0x" << pStruct->flags; 5222// CODEGEN : file ../vk_helper.py line #1113 5223 final_str = prefix + "subresource = " + ss[0].str() + "\n" + prefix + "offset = " + ss[1].str() + "\n" + prefix + "extent = " + ss[2].str() + "\n" + prefix + "memory = " + ss[3].str() + "\n" + prefix + "memoryOffset = " + ss[4].str() + "\n" + prefix + "flags = " + ss[5].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5224 return final_str; 5225} 5226// CODEGEN : file ../vk_helper.py line #906 5227std::string vk_print_vksparseimagememorybindinfo(const VkSparseImageMemoryBindInfo* pStruct, const std::string prefix) 5228{ 5229// CODEGEN : file ../vk_helper.py line #912 5230 using namespace StreamControl; 5231 using namespace std; 5232 string final_str; 5233 string tmp_str; 5234 string extra_indent = " " + prefix; 5235 stringstream ss[3]; 5236 string stp_strs[1]; 5237// CODEGEN : file ../vk_helper.py line #931 5238// CODEGEN : file ../vk_helper.py line #933 5239// CODEGEN : file ../vk_helper.py line #938 5240 stp_strs[0] = ""; 5241 stringstream index_ss; 5242 if (pStruct->pBinds) { 5243 for (uint32_t i = 0; i < pStruct->bindCount; i++) { 5244 index_ss.str(""); 5245 index_ss << i; 5246// CODEGEN : file ../vk_helper.py line #979 5247 ss[0] << "0x" << &pStruct->pBinds[i]; 5248 tmp_str = vk_print_vksparseimagememorybind(&pStruct->pBinds[i], extra_indent); 5249// CODEGEN : file ../vk_helper.py line #983 5250 stp_strs[0] += " " + prefix + "pBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 5251// CODEGEN : file ../vk_helper.py line #999 5252 ss[0].str(""); 5253 } 5254 } 5255// CODEGEN : file ../vk_helper.py line #1085 5256 ss[0] << "0x" << pStruct->image; 5257// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5258 ss[1] << pStruct->bindCount; 5259// CODEGEN : file ../vk_helper.py line #1060 5260 ss[2] << "0x" << (void*)pStruct->pBinds; 5261// CODEGEN : file ../vk_helper.py line #1113 5262 final_str = prefix + "image = " + ss[0].str() + "\n" + prefix + "bindCount = " + ss[1].str() + "\n" + prefix + "pBinds = " + ss[2].str() + "\n" + stp_strs[0]; 5263 return final_str; 5264} 5265// CODEGEN : file ../vk_helper.py line #906 5266std::string vk_print_vksparseimagememoryrequirements(const VkSparseImageMemoryRequirements* pStruct, const std::string prefix) 5267{ 5268// CODEGEN : file ../vk_helper.py line #912 5269 using namespace StreamControl; 5270 using namespace std; 5271 string final_str; 5272 string tmp_str; 5273 string extra_indent = " " + prefix; 5274 stringstream ss[5]; 5275 string stp_strs[1]; 5276// CODEGEN : file ../vk_helper.py line #1037 5277 tmp_str = vk_print_vksparseimageformatproperties(&pStruct->formatProperties, extra_indent); 5278 ss[0] << "0x" << &pStruct->formatProperties; 5279 stp_strs[0] = " " + prefix + "formatProperties (addr)\n" + tmp_str; 5280// CODEGEN : file ../vk_helper.py line #1042 5281 ss[0].str(""); 5282// CODEGEN : file ../vk_helper.py line #1054 5283 ss[0].str("addr"); 5284// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5285 ss[1] << pStruct->imageMipTailFirstLod; 5286// CODEGEN : file ../vk_helper.py line #1085 5287 ss[2] << "0x" << pStruct->imageMipTailSize; 5288// CODEGEN : file ../vk_helper.py line #1085 5289 ss[3] << "0x" << pStruct->imageMipTailOffset; 5290// CODEGEN : file ../vk_helper.py line #1085 5291 ss[4] << "0x" << pStruct->imageMipTailStride; 5292// CODEGEN : file ../vk_helper.py line #1113 5293 final_str = prefix + "formatProperties = " + ss[0].str() + "\n" + prefix + "imageMipTailFirstLod = " + ss[1].str() + "\n" + prefix + "imageMipTailSize = " + ss[2].str() + "\n" + prefix + "imageMipTailOffset = " + ss[3].str() + "\n" + prefix + "imageMipTailStride = " + ss[4].str() + "\n" + stp_strs[0]; 5294 return final_str; 5295} 5296// CODEGEN : file ../vk_helper.py line #906 5297std::string vk_print_vksparseimageopaquememorybindinfo(const VkSparseImageOpaqueMemoryBindInfo* pStruct, const std::string prefix) 5298{ 5299// CODEGEN : file ../vk_helper.py line #912 5300 using namespace StreamControl; 5301 using namespace std; 5302 string final_str; 5303 string tmp_str; 5304 string extra_indent = " " + prefix; 5305 stringstream ss[3]; 5306 string stp_strs[1]; 5307// CODEGEN : file ../vk_helper.py line #931 5308// CODEGEN : file ../vk_helper.py line #933 5309// CODEGEN : file ../vk_helper.py line #938 5310 stp_strs[0] = ""; 5311 stringstream index_ss; 5312 if (pStruct->pBinds) { 5313 for (uint32_t i = 0; i < pStruct->bindCount; i++) { 5314 index_ss.str(""); 5315 index_ss << i; 5316// CODEGEN : file ../vk_helper.py line #979 5317 ss[0] << "0x" << &pStruct->pBinds[i]; 5318 tmp_str = vk_print_vksparsememorybind(&pStruct->pBinds[i], extra_indent); 5319// CODEGEN : file ../vk_helper.py line #983 5320 stp_strs[0] += " " + prefix + "pBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 5321// CODEGEN : file ../vk_helper.py line #999 5322 ss[0].str(""); 5323 } 5324 } 5325// CODEGEN : file ../vk_helper.py line #1085 5326 ss[0] << "0x" << pStruct->image; 5327// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5328 ss[1] << pStruct->bindCount; 5329// CODEGEN : file ../vk_helper.py line #1060 5330 ss[2] << "0x" << (void*)pStruct->pBinds; 5331// CODEGEN : file ../vk_helper.py line #1113 5332 final_str = prefix + "image = " + ss[0].str() + "\n" + prefix + "bindCount = " + ss[1].str() + "\n" + prefix + "pBinds = " + ss[2].str() + "\n" + stp_strs[0]; 5333 return final_str; 5334} 5335// CODEGEN : file ../vk_helper.py line #906 5336std::string vk_print_vksparsememorybind(const VkSparseMemoryBind* pStruct, const std::string prefix) 5337{ 5338// CODEGEN : file ../vk_helper.py line #912 5339 using namespace StreamControl; 5340 using namespace std; 5341 string final_str; 5342 string tmp_str; 5343 string extra_indent = " " + prefix; 5344 stringstream ss[5]; 5345// CODEGEN : file ../vk_helper.py line #1085 5346 ss[0] << "0x" << pStruct->resourceOffset; 5347// CODEGEN : file ../vk_helper.py line #1085 5348 ss[1] << "0x" << pStruct->size; 5349// CODEGEN : file ../vk_helper.py line #1085 5350 ss[2] << "0x" << pStruct->memory; 5351// CODEGEN : file ../vk_helper.py line #1085 5352 ss[3] << "0x" << pStruct->memoryOffset; 5353// CODEGEN : file ../vk_helper.py line #1085 5354 ss[4] << "0x" << pStruct->flags; 5355// CODEGEN : file ../vk_helper.py line #1113 5356 final_str = prefix + "resourceOffset = " + ss[0].str() + "\n" + prefix + "size = " + ss[1].str() + "\n" + prefix + "memory = " + ss[2].str() + "\n" + prefix + "memoryOffset = " + ss[3].str() + "\n" + prefix + "flags = " + ss[4].str() + "\n"; 5357 return final_str; 5358} 5359// CODEGEN : file ../vk_helper.py line #906 5360std::string vk_print_vkspecializationinfo(const VkSpecializationInfo* pStruct, const std::string prefix) 5361{ 5362// CODEGEN : file ../vk_helper.py line #912 5363 using namespace StreamControl; 5364 using namespace std; 5365 string final_str; 5366 string tmp_str; 5367 string extra_indent = " " + prefix; 5368 stringstream ss[4]; 5369 string stp_strs[1]; 5370// CODEGEN : file ../vk_helper.py line #931 5371// CODEGEN : file ../vk_helper.py line #933 5372// CODEGEN : file ../vk_helper.py line #938 5373 stp_strs[0] = ""; 5374 stringstream index_ss; 5375 if (pStruct->pMapEntries) { 5376 for (uint32_t i = 0; i < pStruct->mapEntryCount; i++) { 5377 index_ss.str(""); 5378 index_ss << i; 5379// CODEGEN : file ../vk_helper.py line #979 5380 ss[0] << "0x" << &pStruct->pMapEntries[i]; 5381 tmp_str = vk_print_vkspecializationmapentry(&pStruct->pMapEntries[i], extra_indent); 5382// CODEGEN : file ../vk_helper.py line #983 5383 stp_strs[0] += " " + prefix + "pMapEntries[" + index_ss.str() + "] (addr)\n" + tmp_str; 5384// CODEGEN : file ../vk_helper.py line #999 5385 ss[0].str(""); 5386 } 5387 } 5388// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5389 ss[0] << pStruct->mapEntryCount; 5390// CODEGEN : file ../vk_helper.py line #1060 5391 ss[1] << "0x" << (void*)pStruct->pMapEntries; 5392// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5393 ss[2] << pStruct->dataSize; 5394// CODEGEN : file ../vk_helper.py line #1069 5395 if (StreamControl::writeAddress) 5396 ss[3] << "0x" << pStruct->pData; 5397 else 5398 ss[3].str("address"); 5399// CODEGEN : file ../vk_helper.py line #1113 5400 final_str = prefix + "mapEntryCount = " + ss[0].str() + "\n" + prefix + "pMapEntries = " + ss[1].str() + "\n" + prefix + "dataSize = " + ss[2].str() + "\n" + prefix + "pData = " + ss[3].str() + "\n" + stp_strs[0]; 5401 return final_str; 5402} 5403// CODEGEN : file ../vk_helper.py line #906 5404std::string vk_print_vkspecializationmapentry(const VkSpecializationMapEntry* pStruct, const std::string prefix) 5405{ 5406// CODEGEN : file ../vk_helper.py line #912 5407 using namespace StreamControl; 5408 using namespace std; 5409 string final_str; 5410 string tmp_str; 5411 string extra_indent = " " + prefix; 5412 stringstream ss[3]; 5413// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 5414 ss[0] << "0x" << pStruct->constantID; 5415// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 5416 ss[1] << "0x" << pStruct->offset; 5417// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5418 ss[2] << pStruct->size; 5419// CODEGEN : file ../vk_helper.py line #1113 5420 final_str = prefix + "constantID = " + ss[0].str() + "\n" + prefix + "offset = " + ss[1].str() + "\n" + prefix + "size = " + ss[2].str() + "\n"; 5421 return final_str; 5422} 5423// CODEGEN : file ../vk_helper.py line #906 5424std::string vk_print_vkstencilopstate(const VkStencilOpState* pStruct, const std::string prefix) 5425{ 5426// CODEGEN : file ../vk_helper.py line #912 5427 using namespace StreamControl; 5428 using namespace std; 5429 string final_str; 5430 string tmp_str; 5431 string extra_indent = " " + prefix; 5432 stringstream ss[3]; 5433// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 5434 ss[0] << "0x" << pStruct->compareMask; 5435// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 5436 ss[1] << "0x" << pStruct->writeMask; 5437// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5438 ss[2] << pStruct->reference; 5439// CODEGEN : file ../vk_helper.py line #1113 5440 final_str = prefix + "failOp = " + string_VkStencilOp(pStruct->failOp) + "\n" + prefix + "passOp = " + string_VkStencilOp(pStruct->passOp) + "\n" + prefix + "depthFailOp = " + string_VkStencilOp(pStruct->depthFailOp) + "\n" + prefix + "compareOp = " + string_VkCompareOp(pStruct->compareOp) + "\n" + prefix + "compareMask = " + ss[0].str() + "\n" + prefix + "writeMask = " + ss[1].str() + "\n" + prefix + "reference = " + ss[2].str() + "\n"; 5441 return final_str; 5442} 5443// CODEGEN : file ../vk_helper.py line #906 5444std::string vk_print_vksubmitinfo(const VkSubmitInfo* pStruct, const std::string prefix) 5445{ 5446// CODEGEN : file ../vk_helper.py line #912 5447 using namespace StreamControl; 5448 using namespace std; 5449 string final_str; 5450 string tmp_str; 5451 string extra_indent = " " + prefix; 5452 stringstream ss[8]; 5453 string stp_strs[4]; 5454// CODEGEN : file ../vk_helper.py line #1011 5455 if (pStruct->pNext) { 5456// CODEGEN : file ../vk_helper.py line #1015 5457 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5458 ss[0] << "0x" << &pStruct->pNext; 5459// CODEGEN : file ../vk_helper.py line #1027 5460 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5461 ss[0].str(""); 5462 } 5463 else 5464 stp_strs[0] = ""; 5465// CODEGEN : file ../vk_helper.py line #931 5466// CODEGEN : file ../vk_helper.py line #933 5467// CODEGEN : file ../vk_helper.py line #938 5468 stp_strs[1] = ""; 5469 stringstream index_ss; 5470 if (pStruct->pWaitSemaphores) { 5471 for (uint32_t i = 0; i < pStruct->waitSemaphoreCount; i++) { 5472 index_ss.str(""); 5473 index_ss << i; 5474// CODEGEN : file ../vk_helper.py line #989 5475 ss[1] << "0x" << pStruct->pWaitSemaphores[i]; 5476 stp_strs[1] += " " + prefix + "pWaitSemaphores[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 5477// CODEGEN : file ../vk_helper.py line #999 5478 ss[1].str(""); 5479 } 5480 } 5481// CODEGEN : file ../vk_helper.py line #931 5482// CODEGEN : file ../vk_helper.py line #933 5483// CODEGEN : file ../vk_helper.py line #938 5484 stp_strs[2] = ""; 5485 if (pStruct->pCommandBuffers) { 5486 for (uint32_t i = 0; i < pStruct->commandBufferCount; i++) { 5487 index_ss.str(""); 5488 index_ss << i; 5489// CODEGEN : file ../vk_helper.py line #989 5490 ss[2] << "0x" << pStruct->pCommandBuffers[i]; 5491 stp_strs[2] += " " + prefix + "pCommandBuffers[" + index_ss.str() + "].handle = " + ss[2].str() + "\n"; 5492// CODEGEN : file ../vk_helper.py line #999 5493 ss[2].str(""); 5494 } 5495 } 5496// CODEGEN : file ../vk_helper.py line #931 5497// CODEGEN : file ../vk_helper.py line #933 5498// CODEGEN : file ../vk_helper.py line #938 5499 stp_strs[3] = ""; 5500 if (pStruct->pSignalSemaphores) { 5501 for (uint32_t i = 0; i < pStruct->signalSemaphoreCount; i++) { 5502 index_ss.str(""); 5503 index_ss << i; 5504// CODEGEN : file ../vk_helper.py line #989 5505 ss[3] << "0x" << pStruct->pSignalSemaphores[i]; 5506 stp_strs[3] += " " + prefix + "pSignalSemaphores[" + index_ss.str() + "].handle = " + ss[3].str() + "\n"; 5507// CODEGEN : file ../vk_helper.py line #999 5508 ss[3].str(""); 5509 } 5510 } 5511// CODEGEN : file ../vk_helper.py line #1069 5512 if (StreamControl::writeAddress) 5513 ss[0] << "0x" << pStruct->pNext; 5514 else 5515 ss[0].str("address"); 5516// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5517 ss[1] << pStruct->waitSemaphoreCount; 5518// CODEGEN : file ../vk_helper.py line #1060 5519 ss[2] << "0x" << (void*)pStruct->pWaitSemaphores; 5520// CODEGEN : file ../vk_helper.py line #1085 5521 ss[3] << "0x" << pStruct->pWaitDstStageMask; 5522// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 5523 ss[4] << "0x" << pStruct->commandBufferCount; 5524// CODEGEN : file ../vk_helper.py line #1060 5525 ss[5] << "0x" << (void*)pStruct->pCommandBuffers; 5526// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5527 ss[6] << pStruct->signalSemaphoreCount; 5528// CODEGEN : file ../vk_helper.py line #1060 5529 ss[7] << "0x" << (void*)pStruct->pSignalSemaphores; 5530// CODEGEN : file ../vk_helper.py line #1113 5531 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "waitSemaphoreCount = " + ss[1].str() + "\n" + prefix + "pWaitSemaphores = " + ss[2].str() + "\n" + prefix + "pWaitDstStageMask = " + ss[3].str() + "\n" + prefix + "commandBufferCount = " + ss[4].str() + "\n" + prefix + "pCommandBuffers = " + ss[5].str() + "\n" + prefix + "signalSemaphoreCount = " + ss[6].str() + "\n" + prefix + "pSignalSemaphores = " + ss[7].str() + "\n" + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5532 return final_str; 5533} 5534// CODEGEN : file ../vk_helper.py line #906 5535std::string vk_print_vksubpassdependency(const VkSubpassDependency* pStruct, const std::string prefix) 5536{ 5537// CODEGEN : file ../vk_helper.py line #912 5538 using namespace StreamControl; 5539 using namespace std; 5540 string final_str; 5541 string tmp_str; 5542 string extra_indent = " " + prefix; 5543 stringstream ss[7]; 5544// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5545 ss[0] << pStruct->srcSubpass; 5546// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5547 ss[1] << pStruct->dstSubpass; 5548// CODEGEN : file ../vk_helper.py line #1085 5549 ss[2] << "0x" << pStruct->srcStageMask; 5550// CODEGEN : file ../vk_helper.py line #1085 5551 ss[3] << "0x" << pStruct->dstStageMask; 5552// CODEGEN : file ../vk_helper.py line #1085 5553 ss[4] << "0x" << pStruct->srcAccessMask; 5554// CODEGEN : file ../vk_helper.py line #1085 5555 ss[5] << "0x" << pStruct->dstAccessMask; 5556// CODEGEN : file ../vk_helper.py line #1085 5557 ss[6] << "0x" << pStruct->dependencyFlags; 5558// CODEGEN : file ../vk_helper.py line #1113 5559 final_str = prefix + "srcSubpass = " + ss[0].str() + "\n" + prefix + "dstSubpass = " + ss[1].str() + "\n" + prefix + "srcStageMask = " + ss[2].str() + "\n" + prefix + "dstStageMask = " + ss[3].str() + "\n" + prefix + "srcAccessMask = " + ss[4].str() + "\n" + prefix + "dstAccessMask = " + ss[5].str() + "\n" + prefix + "dependencyFlags = " + ss[6].str() + "\n"; 5560 return final_str; 5561} 5562// CODEGEN : file ../vk_helper.py line #906 5563std::string vk_print_vksubpassdescription(const VkSubpassDescription* pStruct, const std::string prefix) 5564{ 5565// CODEGEN : file ../vk_helper.py line #912 5566 using namespace StreamControl; 5567 using namespace std; 5568 string final_str; 5569 string tmp_str; 5570 string extra_indent = " " + prefix; 5571 stringstream ss[9]; 5572 string stp_strs[5]; 5573// CODEGEN : file ../vk_helper.py line #931 5574// CODEGEN : file ../vk_helper.py line #933 5575// CODEGEN : file ../vk_helper.py line #938 5576 stp_strs[0] = ""; 5577 stringstream index_ss; 5578 if (pStruct->pInputAttachments) { 5579 for (uint32_t i = 0; i < pStruct->inputAttachmentCount; i++) { 5580 index_ss.str(""); 5581 index_ss << i; 5582// CODEGEN : file ../vk_helper.py line #979 5583 ss[0] << "0x" << &pStruct->pInputAttachments[i]; 5584 tmp_str = vk_print_vkattachmentreference(&pStruct->pInputAttachments[i], extra_indent); 5585// CODEGEN : file ../vk_helper.py line #983 5586 stp_strs[0] += " " + prefix + "pInputAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 5587// CODEGEN : file ../vk_helper.py line #999 5588 ss[0].str(""); 5589 } 5590 } 5591// CODEGEN : file ../vk_helper.py line #931 5592// CODEGEN : file ../vk_helper.py line #933 5593// CODEGEN : file ../vk_helper.py line #938 5594 stp_strs[1] = ""; 5595 if (pStruct->pColorAttachments) { 5596 for (uint32_t i = 0; i < pStruct->colorAttachmentCount; i++) { 5597 index_ss.str(""); 5598 index_ss << i; 5599// CODEGEN : file ../vk_helper.py line #979 5600 ss[1] << "0x" << &pStruct->pColorAttachments[i]; 5601 tmp_str = vk_print_vkattachmentreference(&pStruct->pColorAttachments[i], extra_indent); 5602// CODEGEN : file ../vk_helper.py line #983 5603 stp_strs[1] += " " + prefix + "pColorAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 5604// CODEGEN : file ../vk_helper.py line #999 5605 ss[1].str(""); 5606 } 5607 } 5608// CODEGEN : file ../vk_helper.py line #931 5609// CODEGEN : file ../vk_helper.py line #933 5610// CODEGEN : file ../vk_helper.py line #938 5611 stp_strs[2] = ""; 5612 if (pStruct->pResolveAttachments) { 5613 for (uint32_t i = 0; i < pStruct->colorAttachmentCount; i++) { 5614 index_ss.str(""); 5615 index_ss << i; 5616// CODEGEN : file ../vk_helper.py line #979 5617 ss[2] << "0x" << &pStruct->pResolveAttachments[i]; 5618 tmp_str = vk_print_vkattachmentreference(&pStruct->pResolveAttachments[i], extra_indent); 5619// CODEGEN : file ../vk_helper.py line #983 5620 stp_strs[2] += " " + prefix + "pResolveAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 5621// CODEGEN : file ../vk_helper.py line #999 5622 ss[2].str(""); 5623 } 5624 } 5625// CODEGEN : file ../vk_helper.py line #1011 5626 if (pStruct->pDepthStencilAttachment) { 5627// CODEGEN : file ../vk_helper.py line #1023 5628 tmp_str = vk_print_vkattachmentreference(pStruct->pDepthStencilAttachment, extra_indent); 5629 ss[3] << "0x" << &pStruct->pDepthStencilAttachment; 5630// CODEGEN : file ../vk_helper.py line #1027 5631 stp_strs[3] = " " + prefix + "pDepthStencilAttachment (addr)\n" + tmp_str; 5632 ss[3].str(""); 5633 } 5634 else 5635 stp_strs[3] = ""; 5636// CODEGEN : file ../vk_helper.py line #931 5637// CODEGEN : file ../vk_helper.py line #933 5638// CODEGEN : file ../vk_helper.py line #938 5639 stp_strs[4] = ""; 5640 if (pStruct->pPreserveAttachments) { 5641 for (uint32_t i = 0; i < pStruct->preserveAttachmentCount; i++) { 5642 index_ss.str(""); 5643 index_ss << i; 5644// CODEGEN : file ../vk_helper.py line #989 5645 ss[4] << "0x" << pStruct->pPreserveAttachments[i]; 5646 stp_strs[4] += " " + prefix + "pPreserveAttachments[" + index_ss.str() + "] = " + ss[4].str() + "\n"; 5647// CODEGEN : file ../vk_helper.py line #999 5648 ss[4].str(""); 5649 } 5650 } 5651// CODEGEN : file ../vk_helper.py line #1085 5652 ss[0] << "0x" << pStruct->flags; 5653// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5654 ss[1] << pStruct->inputAttachmentCount; 5655// CODEGEN : file ../vk_helper.py line #1060 5656 ss[2] << "0x" << (void*)pStruct->pInputAttachments; 5657// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5658 ss[3] << pStruct->colorAttachmentCount; 5659// CODEGEN : file ../vk_helper.py line #1060 5660 ss[4] << "0x" << (void*)pStruct->pColorAttachments; 5661// CODEGEN : file ../vk_helper.py line #1060 5662 ss[5] << "0x" << (void*)pStruct->pResolveAttachments; 5663// CODEGEN : file ../vk_helper.py line #1085 5664 ss[6] << "0x" << pStruct->pDepthStencilAttachment; 5665// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5666 ss[7] << pStruct->preserveAttachmentCount; 5667// CODEGEN : file ../vk_helper.py line #1060 5668 ss[8] << "0x" << (void*)pStruct->pPreserveAttachments; 5669// CODEGEN : file ../vk_helper.py line #1113 5670 final_str = prefix + "flags = " + ss[0].str() + "\n" + prefix + "pipelineBindPoint = " + string_VkPipelineBindPoint(pStruct->pipelineBindPoint) + "\n" + prefix + "inputAttachmentCount = " + ss[1].str() + "\n" + prefix + "pInputAttachments = " + ss[2].str() + "\n" + prefix + "colorAttachmentCount = " + ss[3].str() + "\n" + prefix + "pColorAttachments = " + ss[4].str() + "\n" + prefix + "pResolveAttachments = " + ss[5].str() + "\n" + prefix + "pDepthStencilAttachment = " + ss[6].str() + "\n" + prefix + "preserveAttachmentCount = " + ss[7].str() + "\n" + prefix + "pPreserveAttachments = " + ss[8].str() + "\n" + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5671 return final_str; 5672} 5673// CODEGEN : file ../vk_helper.py line #906 5674std::string vk_print_vksubresourcelayout(const VkSubresourceLayout* pStruct, const std::string prefix) 5675{ 5676// CODEGEN : file ../vk_helper.py line #912 5677 using namespace StreamControl; 5678 using namespace std; 5679 string final_str; 5680 string tmp_str; 5681 string extra_indent = " " + prefix; 5682 stringstream ss[5]; 5683// CODEGEN : file ../vk_helper.py line #1085 5684 ss[0] << "0x" << pStruct->offset; 5685// CODEGEN : file ../vk_helper.py line #1085 5686 ss[1] << "0x" << pStruct->size; 5687// CODEGEN : file ../vk_helper.py line #1085 5688 ss[2] << "0x" << pStruct->rowPitch; 5689// CODEGEN : file ../vk_helper.py line #1085 5690 ss[3] << "0x" << pStruct->arrayPitch; 5691// CODEGEN : file ../vk_helper.py line #1085 5692 ss[4] << "0x" << pStruct->depthPitch; 5693// CODEGEN : file ../vk_helper.py line #1113 5694 final_str = prefix + "offset = " + ss[0].str() + "\n" + prefix + "size = " + ss[1].str() + "\n" + prefix + "rowPitch = " + ss[2].str() + "\n" + prefix + "arrayPitch = " + ss[3].str() + "\n" + prefix + "depthPitch = " + ss[4].str() + "\n"; 5695 return final_str; 5696} 5697// CODEGEN : file ../vk_helper.py line #906 5698std::string vk_print_vksurfacecapabilitieskhr(const VkSurfaceCapabilitiesKHR* pStruct, const std::string prefix) 5699{ 5700// CODEGEN : file ../vk_helper.py line #912 5701 using namespace StreamControl; 5702 using namespace std; 5703 string final_str; 5704 string tmp_str; 5705 string extra_indent = " " + prefix; 5706 stringstream ss[9]; 5707 string stp_strs[3]; 5708// CODEGEN : file ../vk_helper.py line #1037 5709 tmp_str = vk_print_vkextent2d(&pStruct->currentExtent, extra_indent); 5710 ss[0] << "0x" << &pStruct->currentExtent; 5711 stp_strs[0] = " " + prefix + "currentExtent (addr)\n" + tmp_str; 5712// CODEGEN : file ../vk_helper.py line #1042 5713 ss[0].str(""); 5714// CODEGEN : file ../vk_helper.py line #1037 5715 tmp_str = vk_print_vkextent2d(&pStruct->minImageExtent, extra_indent); 5716 ss[1] << "0x" << &pStruct->minImageExtent; 5717 stp_strs[1] = " " + prefix + "minImageExtent (addr)\n" + tmp_str; 5718// CODEGEN : file ../vk_helper.py line #1042 5719 ss[1].str(""); 5720// CODEGEN : file ../vk_helper.py line #1037 5721 tmp_str = vk_print_vkextent2d(&pStruct->maxImageExtent, extra_indent); 5722 ss[2] << "0x" << &pStruct->maxImageExtent; 5723 stp_strs[2] = " " + prefix + "maxImageExtent (addr)\n" + tmp_str; 5724// CODEGEN : file ../vk_helper.py line #1042 5725 ss[2].str(""); 5726// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5727 ss[0] << pStruct->minImageCount; 5728// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5729 ss[1] << pStruct->maxImageCount; 5730// CODEGEN : file ../vk_helper.py line #1054 5731 ss[2].str("addr"); 5732// CODEGEN : file ../vk_helper.py line #1054 5733 ss[3].str("addr"); 5734// CODEGEN : file ../vk_helper.py line #1054 5735 ss[4].str("addr"); 5736// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5737 ss[5] << pStruct->maxImageArrayLayers; 5738// CODEGEN : file ../vk_helper.py line #1085 5739 ss[6] << "0x" << pStruct->supportedTransforms; 5740// CODEGEN : file ../vk_helper.py line #1085 5741 ss[7] << "0x" << pStruct->supportedCompositeAlpha; 5742// CODEGEN : file ../vk_helper.py line #1085 5743 ss[8] << "0x" << pStruct->supportedUsageFlags; 5744// CODEGEN : file ../vk_helper.py line #1113 5745 final_str = prefix + "minImageCount = " + ss[0].str() + "\n" + prefix + "maxImageCount = " + ss[1].str() + "\n" + prefix + "currentExtent = " + ss[2].str() + "\n" + prefix + "minImageExtent = " + ss[3].str() + "\n" + prefix + "maxImageExtent = " + ss[4].str() + "\n" + prefix + "maxImageArrayLayers = " + ss[5].str() + "\n" + prefix + "supportedTransforms = " + ss[6].str() + "\n" + prefix + "currentTransform = " + string_VkSurfaceTransformFlagBitsKHR(pStruct->currentTransform) + "\n" + prefix + "supportedCompositeAlpha = " + ss[7].str() + "\n" + prefix + "supportedUsageFlags = " + ss[8].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5746 return final_str; 5747} 5748// CODEGEN : file ../vk_helper.py line #906 5749std::string vk_print_vksurfaceformatkhr(const VkSurfaceFormatKHR* pStruct, const std::string prefix) 5750{ 5751// CODEGEN : file ../vk_helper.py line #912 5752 using namespace StreamControl; 5753 using namespace std; 5754 string final_str; 5755 string tmp_str; 5756 string extra_indent = " " + prefix; 5757// CODEGEN : file ../vk_helper.py line #1113 5758 final_str = prefix + "format = " + string_VkFormat(pStruct->format) + "\n" + prefix + "colorSpace = " + string_VkColorSpaceKHR(pStruct->colorSpace) + "\n"; 5759 return final_str; 5760} 5761// CODEGEN : file ../vk_helper.py line #906 5762std::string vk_print_vkswapchaincreateinfokhr(const VkSwapchainCreateInfoKHR* pStruct, const std::string prefix) 5763{ 5764// CODEGEN : file ../vk_helper.py line #912 5765 using namespace StreamControl; 5766 using namespace std; 5767 string final_str; 5768 string tmp_str; 5769 string extra_indent = " " + prefix; 5770 stringstream ss[11]; 5771 string stp_strs[3]; 5772// CODEGEN : file ../vk_helper.py line #1011 5773 if (pStruct->pNext) { 5774// CODEGEN : file ../vk_helper.py line #1015 5775 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5776 ss[0] << "0x" << &pStruct->pNext; 5777// CODEGEN : file ../vk_helper.py line #1027 5778 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5779 ss[0].str(""); 5780 } 5781 else 5782 stp_strs[0] = ""; 5783// CODEGEN : file ../vk_helper.py line #1037 5784 tmp_str = vk_print_vkextent2d(&pStruct->imageExtent, extra_indent); 5785 ss[1] << "0x" << &pStruct->imageExtent; 5786 stp_strs[1] = " " + prefix + "imageExtent (addr)\n" + tmp_str; 5787// CODEGEN : file ../vk_helper.py line #1042 5788 ss[1].str(""); 5789// CODEGEN : file ../vk_helper.py line #931 5790// CODEGEN : file ../vk_helper.py line #933 5791// CODEGEN : file ../vk_helper.py line #938 5792 stp_strs[2] = ""; 5793 stringstream index_ss; 5794 if (pStruct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) { 5795 if (pStruct->pQueueFamilyIndices) { 5796 for (uint32_t i = 0; i < pStruct->queueFamilyIndexCount; i++) { 5797 index_ss.str(""); 5798 index_ss << i; 5799// CODEGEN : file ../vk_helper.py line #989 5800 ss[2] << "0x" << pStruct->pQueueFamilyIndices[i]; 5801 stp_strs[2] += " " + prefix + "pQueueFamilyIndices[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 5802// CODEGEN : file ../vk_helper.py line #999 5803 ss[2].str(""); 5804 } 5805 } 5806 } 5807// CODEGEN : file ../vk_helper.py line #1069 5808 if (StreamControl::writeAddress) 5809 ss[0] << "0x" << pStruct->pNext; 5810 else 5811 ss[0].str("address"); 5812// CODEGEN : file ../vk_helper.py line #1085 5813 ss[1] << "0x" << pStruct->flags; 5814// CODEGEN : file ../vk_helper.py line #1085 5815 ss[2] << "0x" << pStruct->surface; 5816// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5817 ss[3] << pStruct->minImageCount; 5818// CODEGEN : file ../vk_helper.py line #1054 5819 ss[4].str("addr"); 5820// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5821 ss[5] << pStruct->imageArrayLayers; 5822// CODEGEN : file ../vk_helper.py line #1085 5823 ss[6] << "0x" << pStruct->imageUsage; 5824// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5825 ss[7] << pStruct->queueFamilyIndexCount; 5826// CODEGEN : file ../vk_helper.py line #1060 5827 ss[8] << "0x" << (void*)pStruct->pQueueFamilyIndices; 5828// CODEGEN : file ../vk_helper.py line #1063 5829 ss[9].str(pStruct->clipped ? "TRUE" : "FALSE"); 5830// CODEGEN : file ../vk_helper.py line #1085 5831 ss[10] << "0x" << pStruct->oldSwapchain; 5832// CODEGEN : file ../vk_helper.py line #1113 5833 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "surface = " + ss[2].str() + "\n" + prefix + "minImageCount = " + ss[3].str() + "\n" + prefix + "imageFormat = " + string_VkFormat(pStruct->imageFormat) + "\n" + prefix + "imageColorSpace = " + string_VkColorSpaceKHR(pStruct->imageColorSpace) + "\n" + prefix + "imageExtent = " + ss[4].str() + "\n" + prefix + "imageArrayLayers = " + ss[5].str() + "\n" + prefix + "imageUsage = " + ss[6].str() + "\n" + prefix + "imageSharingMode = " + string_VkSharingMode(pStruct->imageSharingMode) + "\n" + prefix + "queueFamilyIndexCount = " + ss[7].str() + "\n" + prefix + "pQueueFamilyIndices = " + ss[8].str() + "\n" + prefix + "preTransform = " + string_VkSurfaceTransformFlagBitsKHR(pStruct->preTransform) + "\n" + prefix + "compositeAlpha = " + string_VkCompositeAlphaFlagBitsKHR(pStruct->compositeAlpha) + "\n" + prefix + "presentMode = " + string_VkPresentModeKHR(pStruct->presentMode) + "\n" + prefix + "clipped = " + ss[9].str() + "\n" + prefix + "oldSwapchain = " + ss[10].str() + "\n" + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5834 return final_str; 5835} 5836// CODEGEN : file ../vk_helper.py line #906 5837std::string vk_print_vkvertexinputattributedescription(const VkVertexInputAttributeDescription* pStruct, const std::string prefix) 5838{ 5839// CODEGEN : file ../vk_helper.py line #912 5840 using namespace StreamControl; 5841 using namespace std; 5842 string final_str; 5843 string tmp_str; 5844 string extra_indent = " " + prefix; 5845 stringstream ss[3]; 5846// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5847 ss[0] << pStruct->location; 5848// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5849 ss[1] << pStruct->binding; 5850// CODEGEN : file ../vk_helper.py line #1089: NB: Edit here to choose hex vs dec output by variable name 5851 ss[2] << "0x" << pStruct->offset; 5852// CODEGEN : file ../vk_helper.py line #1113 5853 final_str = prefix + "location = " + ss[0].str() + "\n" + prefix + "binding = " + ss[1].str() + "\n" + prefix + "format = " + string_VkFormat(pStruct->format) + "\n" + prefix + "offset = " + ss[2].str() + "\n"; 5854 return final_str; 5855} 5856// CODEGEN : file ../vk_helper.py line #906 5857std::string vk_print_vkvertexinputbindingdescription(const VkVertexInputBindingDescription* pStruct, const std::string prefix) 5858{ 5859// CODEGEN : file ../vk_helper.py line #912 5860 using namespace StreamControl; 5861 using namespace std; 5862 string final_str; 5863 string tmp_str; 5864 string extra_indent = " " + prefix; 5865 stringstream ss[2]; 5866// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5867 ss[0] << pStruct->binding; 5868// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5869 ss[1] << pStruct->stride; 5870// CODEGEN : file ../vk_helper.py line #1113 5871 final_str = prefix + "binding = " + ss[0].str() + "\n" + prefix + "stride = " + ss[1].str() + "\n" + prefix + "inputRate = " + string_VkVertexInputRate(pStruct->inputRate) + "\n"; 5872 return final_str; 5873} 5874// CODEGEN : file ../vk_helper.py line #906 5875std::string vk_print_vkviewport(const VkViewport* pStruct, const std::string prefix) 5876{ 5877// CODEGEN : file ../vk_helper.py line #912 5878 using namespace StreamControl; 5879 using namespace std; 5880 string final_str; 5881 string tmp_str; 5882 string extra_indent = " " + prefix; 5883 stringstream ss[6]; 5884// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5885 ss[0] << pStruct->x; 5886// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5887 ss[1] << pStruct->y; 5888// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5889 ss[2] << pStruct->width; 5890// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5891 ss[3] << pStruct->height; 5892// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5893 ss[4] << pStruct->minDepth; 5894// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5895 ss[5] << pStruct->maxDepth; 5896// CODEGEN : file ../vk_helper.py line #1113 5897 final_str = prefix + "x = " + ss[0].str() + "\n" + prefix + "y = " + ss[1].str() + "\n" + prefix + "width = " + ss[2].str() + "\n" + prefix + "height = " + ss[3].str() + "\n" + prefix + "minDepth = " + ss[4].str() + "\n" + prefix + "maxDepth = " + ss[5].str() + "\n"; 5898 return final_str; 5899} 5900// CODEGEN : file ../vk_helper.py line #906 5901#ifdef VK_USE_PLATFORM_WAYLAND_KHR 5902std::string vk_print_vkwaylandsurfacecreateinfokhr(const VkWaylandSurfaceCreateInfoKHR* pStruct, const std::string prefix) 5903{ 5904// CODEGEN : file ../vk_helper.py line #912 5905 using namespace StreamControl; 5906 using namespace std; 5907 string final_str; 5908 string tmp_str; 5909 string extra_indent = " " + prefix; 5910 stringstream ss[4]; 5911 string stp_strs[1]; 5912// CODEGEN : file ../vk_helper.py line #1011 5913 if (pStruct->pNext) { 5914// CODEGEN : file ../vk_helper.py line #1015 5915 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5916 ss[0] << "0x" << &pStruct->pNext; 5917// CODEGEN : file ../vk_helper.py line #1027 5918 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5919 ss[0].str(""); 5920 } 5921 else 5922 stp_strs[0] = ""; 5923// CODEGEN : file ../vk_helper.py line #1069 5924 if (StreamControl::writeAddress) 5925 ss[0] << "0x" << pStruct->pNext; 5926 else 5927 ss[0].str("address"); 5928// CODEGEN : file ../vk_helper.py line #1085 5929 ss[1] << "0x" << pStruct->flags; 5930// CODEGEN : file ../vk_helper.py line #1085 5931 ss[2] << "0x" << pStruct->display; 5932// CODEGEN : file ../vk_helper.py line #1085 5933 ss[3] << "0x" << pStruct->surface; 5934// CODEGEN : file ../vk_helper.py line #1113 5935 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "display = " + ss[2].str() + "\n" + prefix + "surface = " + ss[3].str() + "\n" + stp_strs[0]; 5936 return final_str; 5937} 5938#endif //VK_USE_PLATFORM_WAYLAND_KHR 5939// CODEGEN : file ../vk_helper.py line #906 5940#ifdef VK_USE_PLATFORM_WIN32_KHR 5941std::string vk_print_vkwin32surfacecreateinfokhr(const VkWin32SurfaceCreateInfoKHR* pStruct, const std::string prefix) 5942{ 5943// CODEGEN : file ../vk_helper.py line #912 5944 using namespace StreamControl; 5945 using namespace std; 5946 string final_str; 5947 string tmp_str; 5948 string extra_indent = " " + prefix; 5949 stringstream ss[4]; 5950 string stp_strs[1]; 5951// CODEGEN : file ../vk_helper.py line #1011 5952 if (pStruct->pNext) { 5953// CODEGEN : file ../vk_helper.py line #1015 5954 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5955 ss[0] << "0x" << &pStruct->pNext; 5956// CODEGEN : file ../vk_helper.py line #1027 5957 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5958 ss[0].str(""); 5959 } 5960 else 5961 stp_strs[0] = ""; 5962// CODEGEN : file ../vk_helper.py line #1069 5963 if (StreamControl::writeAddress) 5964 ss[0] << "0x" << pStruct->pNext; 5965 else 5966 ss[0].str("address"); 5967// CODEGEN : file ../vk_helper.py line #1085 5968 ss[1] << "0x" << pStruct->flags; 5969// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5970 ss[2] << pStruct->hinstance; 5971// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 5972 ss[3] << pStruct->hwnd; 5973// CODEGEN : file ../vk_helper.py line #1113 5974 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "hinstance = " + ss[2].str() + "\n" + prefix + "hwnd = " + ss[3].str() + "\n" + stp_strs[0]; 5975 return final_str; 5976} 5977#endif //VK_USE_PLATFORM_WIN32_KHR 5978// CODEGEN : file ../vk_helper.py line #906 5979std::string vk_print_vkwritedescriptorset(const VkWriteDescriptorSet* pStruct, const std::string prefix) 5980{ 5981// CODEGEN : file ../vk_helper.py line #912 5982 using namespace StreamControl; 5983 using namespace std; 5984 string final_str; 5985 string tmp_str; 5986 string extra_indent = " " + prefix; 5987 stringstream ss[8]; 5988 string stp_strs[4]; 5989// CODEGEN : file ../vk_helper.py line #1011 5990 if (pStruct->pNext) { 5991// CODEGEN : file ../vk_helper.py line #1015 5992 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5993 ss[0] << "0x" << &pStruct->pNext; 5994// CODEGEN : file ../vk_helper.py line #1027 5995 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5996 ss[0].str(""); 5997 } 5998 else 5999 stp_strs[0] = ""; 6000// CODEGEN : file ../vk_helper.py line #931 6001// CODEGEN : file ../vk_helper.py line #933 6002// CODEGEN : file ../vk_helper.py line #938 6003 stp_strs[1] = ""; 6004 stringstream index_ss; 6005 if ((pStruct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || 6006 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) || 6007 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || 6008 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)) { 6009 if (pStruct->pImageInfo) { 6010 for (uint32_t i = 0; i < pStruct->descriptorCount; i++) { 6011 index_ss.str(""); 6012 index_ss << i; 6013// CODEGEN : file ../vk_helper.py line #979 6014 ss[1] << "0x" << &pStruct->pImageInfo[i]; 6015 tmp_str = vk_print_vkdescriptorimageinfo(&pStruct->pImageInfo[i], extra_indent); 6016// CODEGEN : file ../vk_helper.py line #983 6017 stp_strs[1] += " " + prefix + "pImageInfo[" + index_ss.str() + "] (addr)\n" + tmp_str; 6018// CODEGEN : file ../vk_helper.py line #999 6019 ss[1].str(""); 6020 } 6021 } 6022 } 6023// CODEGEN : file ../vk_helper.py line #931 6024// CODEGEN : file ../vk_helper.py line #933 6025// CODEGEN : file ../vk_helper.py line #938 6026 stp_strs[2] = ""; 6027 if ((pStruct->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || 6028 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || 6029 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || 6030 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { 6031 if (pStruct->pBufferInfo) { 6032 for (uint32_t i = 0; i < pStruct->descriptorCount; i++) { 6033 index_ss.str(""); 6034 index_ss << i; 6035// CODEGEN : file ../vk_helper.py line #979 6036 ss[2] << "0x" << &pStruct->pBufferInfo[i]; 6037 tmp_str = vk_print_vkdescriptorbufferinfo(&pStruct->pBufferInfo[i], extra_indent); 6038// CODEGEN : file ../vk_helper.py line #983 6039 stp_strs[2] += " " + prefix + "pBufferInfo[" + index_ss.str() + "] (addr)\n" + tmp_str; 6040// CODEGEN : file ../vk_helper.py line #999 6041 ss[2].str(""); 6042 } 6043 } 6044 } 6045// CODEGEN : file ../vk_helper.py line #931 6046// CODEGEN : file ../vk_helper.py line #933 6047// CODEGEN : file ../vk_helper.py line #938 6048 stp_strs[3] = ""; 6049 if ((pStruct->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) || 6050 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) { 6051 if (pStruct->pTexelBufferView) { 6052 for (uint32_t i = 0; i < pStruct->descriptorCount; i++) { 6053 index_ss.str(""); 6054 index_ss << i; 6055// CODEGEN : file ../vk_helper.py line #989 6056 ss[3] << "0x" << pStruct->pTexelBufferView[i]; 6057 stp_strs[3] += " " + prefix + "pTexelBufferView[" + index_ss.str() + "].handle = " + ss[3].str() + "\n"; 6058// CODEGEN : file ../vk_helper.py line #999 6059 ss[3].str(""); 6060 } 6061 } 6062 } 6063// CODEGEN : file ../vk_helper.py line #1069 6064 if (StreamControl::writeAddress) 6065 ss[0] << "0x" << pStruct->pNext; 6066 else 6067 ss[0].str("address"); 6068// CODEGEN : file ../vk_helper.py line #1085 6069 ss[1] << "0x" << pStruct->dstSet; 6070// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 6071 ss[2] << pStruct->dstBinding; 6072// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 6073 ss[3] << pStruct->dstArrayElement; 6074// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 6075 ss[4] << pStruct->descriptorCount; 6076// CODEGEN : file ../vk_helper.py line #1060 6077 ss[5] << "0x" << (void*)pStruct->pImageInfo; 6078// CODEGEN : file ../vk_helper.py line #1060 6079 ss[6] << "0x" << (void*)pStruct->pBufferInfo; 6080// CODEGEN : file ../vk_helper.py line #1060 6081 ss[7] << "0x" << (void*)pStruct->pTexelBufferView; 6082// CODEGEN : file ../vk_helper.py line #1113 6083 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "dstSet = " + ss[1].str() + "\n" + prefix + "dstBinding = " + ss[2].str() + "\n" + prefix + "dstArrayElement = " + ss[3].str() + "\n" + prefix + "descriptorCount = " + ss[4].str() + "\n" + prefix + "descriptorType = " + string_VkDescriptorType(pStruct->descriptorType) + "\n" + prefix + "pImageInfo = " + ss[5].str() + "\n" + prefix + "pBufferInfo = " + ss[6].str() + "\n" + prefix + "pTexelBufferView = " + ss[7].str() + "\n" + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 6084 return final_str; 6085} 6086// CODEGEN : file ../vk_helper.py line #906 6087#ifdef VK_USE_PLATFORM_XCB_KHR 6088std::string vk_print_vkxcbsurfacecreateinfokhr(const VkXcbSurfaceCreateInfoKHR* pStruct, const std::string prefix) 6089{ 6090// CODEGEN : file ../vk_helper.py line #912 6091 using namespace StreamControl; 6092 using namespace std; 6093 string final_str; 6094 string tmp_str; 6095 string extra_indent = " " + prefix; 6096 stringstream ss[4]; 6097 string stp_strs[1]; 6098// CODEGEN : file ../vk_helper.py line #1011 6099 if (pStruct->pNext) { 6100// CODEGEN : file ../vk_helper.py line #1015 6101 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 6102 ss[0] << "0x" << &pStruct->pNext; 6103// CODEGEN : file ../vk_helper.py line #1027 6104 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 6105 ss[0].str(""); 6106 } 6107 else 6108 stp_strs[0] = ""; 6109// CODEGEN : file ../vk_helper.py line #1069 6110 if (StreamControl::writeAddress) 6111 ss[0] << "0x" << pStruct->pNext; 6112 else 6113 ss[0].str("address"); 6114// CODEGEN : file ../vk_helper.py line #1085 6115 ss[1] << "0x" << pStruct->flags; 6116// CODEGEN : file ../vk_helper.py line #1085 6117 ss[2] << "0x" << pStruct->connection; 6118// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 6119 ss[3] << pStruct->window; 6120// CODEGEN : file ../vk_helper.py line #1113 6121 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "connection = " + ss[2].str() + "\n" + prefix + "window = " + ss[3].str() + "\n" + stp_strs[0]; 6122 return final_str; 6123} 6124#endif //VK_USE_PLATFORM_XCB_KHR 6125// CODEGEN : file ../vk_helper.py line #906 6126#ifdef VK_USE_PLATFORM_XLIB_KHR 6127std::string vk_print_vkxlibsurfacecreateinfokhr(const VkXlibSurfaceCreateInfoKHR* pStruct, const std::string prefix) 6128{ 6129// CODEGEN : file ../vk_helper.py line #912 6130 using namespace StreamControl; 6131 using namespace std; 6132 string final_str; 6133 string tmp_str; 6134 string extra_indent = " " + prefix; 6135 stringstream ss[4]; 6136 string stp_strs[1]; 6137// CODEGEN : file ../vk_helper.py line #1011 6138 if (pStruct->pNext) { 6139// CODEGEN : file ../vk_helper.py line #1015 6140 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 6141 ss[0] << "0x" << &pStruct->pNext; 6142// CODEGEN : file ../vk_helper.py line #1027 6143 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 6144 ss[0].str(""); 6145 } 6146 else 6147 stp_strs[0] = ""; 6148// CODEGEN : file ../vk_helper.py line #1069 6149 if (StreamControl::writeAddress) 6150 ss[0] << "0x" << pStruct->pNext; 6151 else 6152 ss[0].str("address"); 6153// CODEGEN : file ../vk_helper.py line #1085 6154 ss[1] << "0x" << pStruct->flags; 6155// CODEGEN : file ../vk_helper.py line #1085 6156 ss[2] << "0x" << pStruct->dpy; 6157// CODEGEN : file ../vk_helper.py line #1092: NB Edit this section to choose hex vs dec output by variable name 6158 ss[3] << pStruct->window; 6159// CODEGEN : file ../vk_helper.py line #1113 6160 final_str = prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n" + prefix + "pNext = " + ss[0].str() + "\n" + prefix + "flags = " + ss[1].str() + "\n" + prefix + "dpy = " + ss[2].str() + "\n" + prefix + "window = " + ss[3].str() + "\n" + stp_strs[0]; 6161 return final_str; 6162} 6163#endif //VK_USE_PLATFORM_XLIB_KHR 6164// CODEGEN : file ../vk_helper.py line #1121 6165std::string string_convert_helper(const void* toString, const std::string prefix) 6166{ 6167 using namespace StreamControl; 6168 using namespace std; 6169 stringstream ss; 6170 ss << toString; 6171 string final_str = prefix + ss.str(); 6172 return final_str; 6173} 6174// CODEGEN : file ../vk_helper.py line #1130 6175std::string string_convert_helper(const uint64_t toString, const std::string prefix) 6176{ 6177 using namespace StreamControl; 6178 using namespace std; 6179 stringstream ss; 6180 ss << toString; 6181 string final_str = prefix + ss.str(); 6182 return final_str; 6183} 6184// CODEGEN : file ../vk_helper.py line #1140 6185std::string string_convert_helper(VkSurfaceFormatKHR toString, const std::string prefix) 6186{ 6187 using namespace std; 6188 string final_str = prefix + "format = " + string_VkFormat(toString.format) + "format = " + string_VkColorSpaceKHR(toString.colorSpace); 6189 return final_str; 6190} 6191// CODEGEN : file ../vk_helper.py line #1147 6192std::string dynamic_display(const void* pStruct, const std::string prefix) 6193{ 6194 using namespace std; 6195 // Cast to APP_INFO ptr initially just to pull sType off struct 6196 if (pStruct == NULL) { 6197 6198 return string(); 6199 } 6200 6201 VkStructureType sType = ((VkApplicationInfo*)pStruct)->sType; 6202 string indent = " "; 6203 indent += prefix; 6204 switch (sType) 6205 { 6206 case VK_STRUCTURE_TYPE_APPLICATION_INFO: 6207 { 6208 return vk_print_vkapplicationinfo((VkApplicationInfo*)pStruct, indent); 6209 } 6210 break; 6211 case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: 6212 { 6213 return vk_print_vkbindsparseinfo((VkBindSparseInfo*)pStruct, indent); 6214 } 6215 break; 6216 case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: 6217 { 6218 return vk_print_vkbuffercreateinfo((VkBufferCreateInfo*)pStruct, indent); 6219 } 6220 break; 6221 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: 6222 { 6223 return vk_print_vkbuffermemorybarrier((VkBufferMemoryBarrier*)pStruct, indent); 6224 } 6225 break; 6226 case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: 6227 { 6228 return vk_print_vkbufferviewcreateinfo((VkBufferViewCreateInfo*)pStruct, indent); 6229 } 6230 break; 6231 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: 6232 { 6233 return vk_print_vkcommandbufferallocateinfo((VkCommandBufferAllocateInfo*)pStruct, indent); 6234 } 6235 break; 6236 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: 6237 { 6238 return vk_print_vkcommandbufferbegininfo((VkCommandBufferBeginInfo*)pStruct, indent); 6239 } 6240 break; 6241 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: 6242 { 6243 return vk_print_vkcommandbufferinheritanceinfo((VkCommandBufferInheritanceInfo*)pStruct, indent); 6244 } 6245 break; 6246 case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: 6247 { 6248 return vk_print_vkcommandpoolcreateinfo((VkCommandPoolCreateInfo*)pStruct, indent); 6249 } 6250 break; 6251 case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: 6252 { 6253 return vk_print_vkcomputepipelinecreateinfo((VkComputePipelineCreateInfo*)pStruct, indent); 6254 } 6255 break; 6256 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: 6257 { 6258 return vk_print_vkcopydescriptorset((VkCopyDescriptorSet*)pStruct, indent); 6259 } 6260 break; 6261 case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: 6262 { 6263 return vk_print_vkdescriptorpoolcreateinfo((VkDescriptorPoolCreateInfo*)pStruct, indent); 6264 } 6265 break; 6266 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: 6267 { 6268 return vk_print_vkdescriptorsetallocateinfo((VkDescriptorSetAllocateInfo*)pStruct, indent); 6269 } 6270 break; 6271 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: 6272 { 6273 return vk_print_vkdescriptorsetlayoutcreateinfo((VkDescriptorSetLayoutCreateInfo*)pStruct, indent); 6274 } 6275 break; 6276 case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: 6277 { 6278 return vk_print_vkdevicecreateinfo((VkDeviceCreateInfo*)pStruct, indent); 6279 } 6280 break; 6281 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: 6282 { 6283 return vk_print_vkdevicequeuecreateinfo((VkDeviceQueueCreateInfo*)pStruct, indent); 6284 } 6285 break; 6286 case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: 6287 { 6288 return vk_print_vkeventcreateinfo((VkEventCreateInfo*)pStruct, indent); 6289 } 6290 break; 6291 case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: 6292 { 6293 return vk_print_vkfencecreateinfo((VkFenceCreateInfo*)pStruct, indent); 6294 } 6295 break; 6296 case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: 6297 { 6298 return vk_print_vkframebuffercreateinfo((VkFramebufferCreateInfo*)pStruct, indent); 6299 } 6300 break; 6301 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: 6302 { 6303 return vk_print_vkgraphicspipelinecreateinfo((VkGraphicsPipelineCreateInfo*)pStruct, indent); 6304 } 6305 break; 6306 case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: 6307 { 6308 return vk_print_vkimagecreateinfo((VkImageCreateInfo*)pStruct, indent); 6309 } 6310 break; 6311 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: 6312 { 6313 return vk_print_vkimagememorybarrier((VkImageMemoryBarrier*)pStruct, indent); 6314 } 6315 break; 6316 case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: 6317 { 6318 return vk_print_vkimageviewcreateinfo((VkImageViewCreateInfo*)pStruct, indent); 6319 } 6320 break; 6321 case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: 6322 { 6323 return vk_print_vkinstancecreateinfo((VkInstanceCreateInfo*)pStruct, indent); 6324 } 6325 break; 6326 case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: 6327 { 6328 return vk_print_vkmappedmemoryrange((VkMappedMemoryRange*)pStruct, indent); 6329 } 6330 break; 6331 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: 6332 { 6333 return vk_print_vkmemoryallocateinfo((VkMemoryAllocateInfo*)pStruct, indent); 6334 } 6335 break; 6336 case VK_STRUCTURE_TYPE_MEMORY_BARRIER: 6337 { 6338 return vk_print_vkmemorybarrier((VkMemoryBarrier*)pStruct, indent); 6339 } 6340 break; 6341 case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: 6342 { 6343 return vk_print_vkpipelinecachecreateinfo((VkPipelineCacheCreateInfo*)pStruct, indent); 6344 } 6345 break; 6346 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: 6347 { 6348 return vk_print_vkpipelinecolorblendstatecreateinfo((VkPipelineColorBlendStateCreateInfo*)pStruct, indent); 6349 } 6350 break; 6351 case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: 6352 { 6353 return vk_print_vkpipelinedepthstencilstatecreateinfo((VkPipelineDepthStencilStateCreateInfo*)pStruct, indent); 6354 } 6355 break; 6356 case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: 6357 { 6358 return vk_print_vkpipelinedynamicstatecreateinfo((VkPipelineDynamicStateCreateInfo*)pStruct, indent); 6359 } 6360 break; 6361 case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: 6362 { 6363 return vk_print_vkpipelineinputassemblystatecreateinfo((VkPipelineInputAssemblyStateCreateInfo*)pStruct, indent); 6364 } 6365 break; 6366 case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: 6367 { 6368 return vk_print_vkpipelinelayoutcreateinfo((VkPipelineLayoutCreateInfo*)pStruct, indent); 6369 } 6370 break; 6371 case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: 6372 { 6373 return vk_print_vkpipelinemultisamplestatecreateinfo((VkPipelineMultisampleStateCreateInfo*)pStruct, indent); 6374 } 6375 break; 6376 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: 6377 { 6378 return vk_print_vkpipelinerasterizationstatecreateinfo((VkPipelineRasterizationStateCreateInfo*)pStruct, indent); 6379 } 6380 break; 6381 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: 6382 { 6383 return vk_print_vkpipelineshaderstagecreateinfo((VkPipelineShaderStageCreateInfo*)pStruct, indent); 6384 } 6385 break; 6386 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: 6387 { 6388 return vk_print_vkpipelinetessellationstatecreateinfo((VkPipelineTessellationStateCreateInfo*)pStruct, indent); 6389 } 6390 break; 6391 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: 6392 { 6393 return vk_print_vkpipelinevertexinputstatecreateinfo((VkPipelineVertexInputStateCreateInfo*)pStruct, indent); 6394 } 6395 break; 6396 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: 6397 { 6398 return vk_print_vkpipelineviewportstatecreateinfo((VkPipelineViewportStateCreateInfo*)pStruct, indent); 6399 } 6400 break; 6401 case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: 6402 { 6403 return vk_print_vkquerypoolcreateinfo((VkQueryPoolCreateInfo*)pStruct, indent); 6404 } 6405 break; 6406 case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: 6407 { 6408 return vk_print_vkrenderpassbegininfo((VkRenderPassBeginInfo*)pStruct, indent); 6409 } 6410 break; 6411 case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: 6412 { 6413 return vk_print_vkrenderpasscreateinfo((VkRenderPassCreateInfo*)pStruct, indent); 6414 } 6415 break; 6416 case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: 6417 { 6418 return vk_print_vksamplercreateinfo((VkSamplerCreateInfo*)pStruct, indent); 6419 } 6420 break; 6421 case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: 6422 { 6423 return vk_print_vksemaphorecreateinfo((VkSemaphoreCreateInfo*)pStruct, indent); 6424 } 6425 break; 6426 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: 6427 { 6428 return vk_print_vkshadermodulecreateinfo((VkShaderModuleCreateInfo*)pStruct, indent); 6429 } 6430 break; 6431 case VK_STRUCTURE_TYPE_SUBMIT_INFO: 6432 { 6433 return vk_print_vksubmitinfo((VkSubmitInfo*)pStruct, indent); 6434 } 6435 break; 6436 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: 6437 { 6438 return vk_print_vkwritedescriptorset((VkWriteDescriptorSet*)pStruct, indent); 6439 } 6440 break; 6441 default: 6442 return string(); 6443// CODEGEN : file ../vk_helper.py line #1173 6444 } 6445}