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 (at) LunarG.com> 24 * Author: Tobin Ehlis <tobin (at) 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" 35 namespace StreamControl 36 { 37 bool writeAddress = true; 38 template <typename T> 39 std::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 } 51 std::ostream& operator<<(std::ostream &out, char const*const s) 52 { 53 return std::operator<<(out, s); 54 } 55 } 56 57 std::string dynamic_display(const void* pStruct, const std::string prefix); 58 // CODEGEN : file ../vk_helper.py line #888 59 std::string vk_print_vkallocationcallbacks(const VkAllocationCallbacks* pStruct, const std::string prefix); 60 #ifdef VK_USE_PLATFORM_ANDROID_KHR 61 std::string vk_print_vkandroidsurfacecreateinfokhr(const VkAndroidSurfaceCreateInfoKHR* pStruct, const std::string prefix); 62 #endif //VK_USE_PLATFORM_ANDROID_KHR 63 std::string vk_print_vkapplicationinfo(const VkApplicationInfo* pStruct, const std::string prefix); 64 std::string vk_print_vkattachmentdescription(const VkAttachmentDescription* pStruct, const std::string prefix); 65 std::string vk_print_vkattachmentreference(const VkAttachmentReference* pStruct, const std::string prefix); 66 std::string vk_print_vkbindsparseinfo(const VkBindSparseInfo* pStruct, const std::string prefix); 67 std::string vk_print_vkbuffercopy(const VkBufferCopy* pStruct, const std::string prefix); 68 std::string vk_print_vkbuffercreateinfo(const VkBufferCreateInfo* pStruct, const std::string prefix); 69 std::string vk_print_vkbufferimagecopy(const VkBufferImageCopy* pStruct, const std::string prefix); 70 std::string vk_print_vkbuffermemorybarrier(const VkBufferMemoryBarrier* pStruct, const std::string prefix); 71 std::string vk_print_vkbufferviewcreateinfo(const VkBufferViewCreateInfo* pStruct, const std::string prefix); 72 std::string vk_print_vkclearattachment(const VkClearAttachment* pStruct, const std::string prefix); 73 std::string vk_print_vkclearcolorvalue(const VkClearColorValue* pStruct, const std::string prefix); 74 std::string vk_print_vkcleardepthstencilvalue(const VkClearDepthStencilValue* pStruct, const std::string prefix); 75 std::string vk_print_vkclearrect(const VkClearRect* pStruct, const std::string prefix); 76 std::string vk_print_vkclearvalue(const VkClearValue* pStruct, const std::string prefix); 77 std::string vk_print_vkcommandbufferallocateinfo(const VkCommandBufferAllocateInfo* pStruct, const std::string prefix); 78 std::string vk_print_vkcommandbufferbegininfo(const VkCommandBufferBeginInfo* pStruct, const std::string prefix); 79 std::string vk_print_vkcommandbufferinheritanceinfo(const VkCommandBufferInheritanceInfo* pStruct, const std::string prefix); 80 std::string vk_print_vkcommandpoolcreateinfo(const VkCommandPoolCreateInfo* pStruct, const std::string prefix); 81 std::string vk_print_vkcomponentmapping(const VkComponentMapping* pStruct, const std::string prefix); 82 std::string vk_print_vkcomputepipelinecreateinfo(const VkComputePipelineCreateInfo* pStruct, const std::string prefix); 83 std::string vk_print_vkcopydescriptorset(const VkCopyDescriptorSet* pStruct, const std::string prefix); 84 std::string vk_print_vkdebugmarkermarkerinfoext(const VkDebugMarkerMarkerInfoEXT* pStruct, const std::string prefix); 85 std::string vk_print_vkdebugmarkerobjectnameinfoext(const VkDebugMarkerObjectNameInfoEXT* pStruct, const std::string prefix); 86 std::string vk_print_vkdebugmarkerobjecttaginfoext(const VkDebugMarkerObjectTagInfoEXT* pStruct, const std::string prefix); 87 std::string vk_print_vkdebugreportcallbackcreateinfoext(const VkDebugReportCallbackCreateInfoEXT* pStruct, const std::string prefix); 88 std::string vk_print_vkdescriptorbufferinfo(const VkDescriptorBufferInfo* pStruct, const std::string prefix); 89 std::string vk_print_vkdescriptorimageinfo(const VkDescriptorImageInfo* pStruct, const std::string prefix); 90 std::string vk_print_vkdescriptorpoolcreateinfo(const VkDescriptorPoolCreateInfo* pStruct, const std::string prefix); 91 std::string vk_print_vkdescriptorpoolsize(const VkDescriptorPoolSize* pStruct, const std::string prefix); 92 std::string vk_print_vkdescriptorsetallocateinfo(const VkDescriptorSetAllocateInfo* pStruct, const std::string prefix); 93 std::string vk_print_vkdescriptorsetlayoutbinding(const VkDescriptorSetLayoutBinding* pStruct, const std::string prefix); 94 std::string vk_print_vkdescriptorsetlayoutcreateinfo(const VkDescriptorSetLayoutCreateInfo* pStruct, const std::string prefix); 95 std::string vk_print_vkdevicecreateinfo(const VkDeviceCreateInfo* pStruct, const std::string prefix); 96 std::string vk_print_vkdevicequeuecreateinfo(const VkDeviceQueueCreateInfo* pStruct, const std::string prefix); 97 std::string vk_print_vkdispatchindirectcommand(const VkDispatchIndirectCommand* pStruct, const std::string prefix); 98 std::string vk_print_vkdisplaymodecreateinfokhr(const VkDisplayModeCreateInfoKHR* pStruct, const std::string prefix); 99 std::string vk_print_vkdisplaymodeparameterskhr(const VkDisplayModeParametersKHR* pStruct, const std::string prefix); 100 std::string vk_print_vkdisplaymodepropertieskhr(const VkDisplayModePropertiesKHR* pStruct, const std::string prefix); 101 std::string vk_print_vkdisplayplanecapabilitieskhr(const VkDisplayPlaneCapabilitiesKHR* pStruct, const std::string prefix); 102 std::string vk_print_vkdisplayplanepropertieskhr(const VkDisplayPlanePropertiesKHR* pStruct, const std::string prefix); 103 std::string vk_print_vkdisplaypresentinfokhr(const VkDisplayPresentInfoKHR* pStruct, const std::string prefix); 104 std::string vk_print_vkdisplaypropertieskhr(const VkDisplayPropertiesKHR* pStruct, const std::string prefix); 105 std::string vk_print_vkdisplaysurfacecreateinfokhr(const VkDisplaySurfaceCreateInfoKHR* pStruct, const std::string prefix); 106 std::string vk_print_vkdrawindexedindirectcommand(const VkDrawIndexedIndirectCommand* pStruct, const std::string prefix); 107 std::string vk_print_vkdrawindirectcommand(const VkDrawIndirectCommand* pStruct, const std::string prefix); 108 std::string vk_print_vkeventcreateinfo(const VkEventCreateInfo* pStruct, const std::string prefix); 109 std::string vk_print_vkextensionproperties(const VkExtensionProperties* pStruct, const std::string prefix); 110 std::string vk_print_vkextent2d(const VkExtent2D* pStruct, const std::string prefix); 111 std::string vk_print_vkextent3d(const VkExtent3D* pStruct, const std::string prefix); 112 std::string vk_print_vkfencecreateinfo(const VkFenceCreateInfo* pStruct, const std::string prefix); 113 std::string vk_print_vkformatproperties(const VkFormatProperties* pStruct, const std::string prefix); 114 std::string vk_print_vkframebuffercreateinfo(const VkFramebufferCreateInfo* pStruct, const std::string prefix); 115 std::string vk_print_vkgraphicspipelinecreateinfo(const VkGraphicsPipelineCreateInfo* pStruct, const std::string prefix); 116 std::string vk_print_vkimageblit(const VkImageBlit* pStruct, const std::string prefix); 117 std::string vk_print_vkimagecopy(const VkImageCopy* pStruct, const std::string prefix); 118 std::string vk_print_vkimagecreateinfo(const VkImageCreateInfo* pStruct, const std::string prefix); 119 std::string vk_print_vkimageformatproperties(const VkImageFormatProperties* pStruct, const std::string prefix); 120 std::string vk_print_vkimagememorybarrier(const VkImageMemoryBarrier* pStruct, const std::string prefix); 121 std::string vk_print_vkimageresolve(const VkImageResolve* pStruct, const std::string prefix); 122 std::string vk_print_vkimagesubresource(const VkImageSubresource* pStruct, const std::string prefix); 123 std::string vk_print_vkimagesubresourcelayers(const VkImageSubresourceLayers* pStruct, const std::string prefix); 124 std::string vk_print_vkimagesubresourcerange(const VkImageSubresourceRange* pStruct, const std::string prefix); 125 std::string vk_print_vkimageviewcreateinfo(const VkImageViewCreateInfo* pStruct, const std::string prefix); 126 std::string vk_print_vkinstancecreateinfo(const VkInstanceCreateInfo* pStruct, const std::string prefix); 127 std::string vk_print_vklayerproperties(const VkLayerProperties* pStruct, const std::string prefix); 128 std::string vk_print_vkmappedmemoryrange(const VkMappedMemoryRange* pStruct, const std::string prefix); 129 std::string vk_print_vkmemoryallocateinfo(const VkMemoryAllocateInfo* pStruct, const std::string prefix); 130 std::string vk_print_vkmemorybarrier(const VkMemoryBarrier* pStruct, const std::string prefix); 131 std::string vk_print_vkmemoryheap(const VkMemoryHeap* pStruct, const std::string prefix); 132 std::string vk_print_vkmemoryrequirements(const VkMemoryRequirements* pStruct, const std::string prefix); 133 std::string vk_print_vkmemorytype(const VkMemoryType* pStruct, const std::string prefix); 134 #ifdef VK_USE_PLATFORM_MIR_KHR 135 std::string vk_print_vkmirsurfacecreateinfokhr(const VkMirSurfaceCreateInfoKHR* pStruct, const std::string prefix); 136 #endif //VK_USE_PLATFORM_MIR_KHR 137 std::string vk_print_vkoffset2d(const VkOffset2D* pStruct, const std::string prefix); 138 std::string vk_print_vkoffset3d(const VkOffset3D* pStruct, const std::string prefix); 139 std::string vk_print_vkphysicaldevicefeatures(const VkPhysicalDeviceFeatures* pStruct, const std::string prefix); 140 std::string vk_print_vkphysicaldevicelimits(const VkPhysicalDeviceLimits* pStruct, const std::string prefix); 141 std::string vk_print_vkphysicaldevicememoryproperties(const VkPhysicalDeviceMemoryProperties* pStruct, const std::string prefix); 142 std::string vk_print_vkphysicaldeviceproperties(const VkPhysicalDeviceProperties* pStruct, const std::string prefix); 143 std::string vk_print_vkphysicaldevicesparseproperties(const VkPhysicalDeviceSparseProperties* pStruct, const std::string prefix); 144 std::string vk_print_vkpipelinecachecreateinfo(const VkPipelineCacheCreateInfo* pStruct, const std::string prefix); 145 std::string vk_print_vkpipelinecolorblendattachmentstate(const VkPipelineColorBlendAttachmentState* pStruct, const std::string prefix); 146 std::string vk_print_vkpipelinecolorblendstatecreateinfo(const VkPipelineColorBlendStateCreateInfo* pStruct, const std::string prefix); 147 std::string vk_print_vkpipelinedepthstencilstatecreateinfo(const VkPipelineDepthStencilStateCreateInfo* pStruct, const std::string prefix); 148 std::string vk_print_vkpipelinedynamicstatecreateinfo(const VkPipelineDynamicStateCreateInfo* pStruct, const std::string prefix); 149 std::string vk_print_vkpipelineinputassemblystatecreateinfo(const VkPipelineInputAssemblyStateCreateInfo* pStruct, const std::string prefix); 150 std::string vk_print_vkpipelinelayoutcreateinfo(const VkPipelineLayoutCreateInfo* pStruct, const std::string prefix); 151 std::string vk_print_vkpipelinemultisamplestatecreateinfo(const VkPipelineMultisampleStateCreateInfo* pStruct, const std::string prefix); 152 std::string vk_print_vkpipelinerasterizationstatecreateinfo(const VkPipelineRasterizationStateCreateInfo* pStruct, const std::string prefix); 153 std::string vk_print_vkpipelinerasterizationstaterasterizationorderamd(const VkPipelineRasterizationStateRasterizationOrderAMD* pStruct, const std::string prefix); 154 std::string vk_print_vkpipelineshaderstagecreateinfo(const VkPipelineShaderStageCreateInfo* pStruct, const std::string prefix); 155 std::string vk_print_vkpipelinetessellationstatecreateinfo(const VkPipelineTessellationStateCreateInfo* pStruct, const std::string prefix); 156 std::string vk_print_vkpipelinevertexinputstatecreateinfo(const VkPipelineVertexInputStateCreateInfo* pStruct, const std::string prefix); 157 std::string vk_print_vkpipelineviewportstatecreateinfo(const VkPipelineViewportStateCreateInfo* pStruct, const std::string prefix); 158 std::string vk_print_vkpresentinfokhr(const VkPresentInfoKHR* pStruct, const std::string prefix); 159 std::string vk_print_vkpushconstantrange(const VkPushConstantRange* pStruct, const std::string prefix); 160 std::string vk_print_vkquerypoolcreateinfo(const VkQueryPoolCreateInfo* pStruct, const std::string prefix); 161 std::string vk_print_vkqueuefamilyproperties(const VkQueueFamilyProperties* pStruct, const std::string prefix); 162 std::string vk_print_vkrect2d(const VkRect2D* pStruct, const std::string prefix); 163 std::string vk_print_vkrenderpassbegininfo(const VkRenderPassBeginInfo* pStruct, const std::string prefix); 164 std::string vk_print_vkrenderpasscreateinfo(const VkRenderPassCreateInfo* pStruct, const std::string prefix); 165 std::string vk_print_vksamplercreateinfo(const VkSamplerCreateInfo* pStruct, const std::string prefix); 166 std::string vk_print_vksemaphorecreateinfo(const VkSemaphoreCreateInfo* pStruct, const std::string prefix); 167 std::string vk_print_vkshadermodulecreateinfo(const VkShaderModuleCreateInfo* pStruct, const std::string prefix); 168 std::string vk_print_vksparsebuffermemorybindinfo(const VkSparseBufferMemoryBindInfo* pStruct, const std::string prefix); 169 std::string vk_print_vksparseimageformatproperties(const VkSparseImageFormatProperties* pStruct, const std::string prefix); 170 std::string vk_print_vksparseimagememorybind(const VkSparseImageMemoryBind* pStruct, const std::string prefix); 171 std::string vk_print_vksparseimagememorybindinfo(const VkSparseImageMemoryBindInfo* pStruct, const std::string prefix); 172 std::string vk_print_vksparseimagememoryrequirements(const VkSparseImageMemoryRequirements* pStruct, const std::string prefix); 173 std::string vk_print_vksparseimageopaquememorybindinfo(const VkSparseImageOpaqueMemoryBindInfo* pStruct, const std::string prefix); 174 std::string vk_print_vksparsememorybind(const VkSparseMemoryBind* pStruct, const std::string prefix); 175 std::string vk_print_vkspecializationinfo(const VkSpecializationInfo* pStruct, const std::string prefix); 176 std::string vk_print_vkspecializationmapentry(const VkSpecializationMapEntry* pStruct, const std::string prefix); 177 std::string vk_print_vkstencilopstate(const VkStencilOpState* pStruct, const std::string prefix); 178 std::string vk_print_vksubmitinfo(const VkSubmitInfo* pStruct, const std::string prefix); 179 std::string vk_print_vksubpassdependency(const VkSubpassDependency* pStruct, const std::string prefix); 180 std::string vk_print_vksubpassdescription(const VkSubpassDescription* pStruct, const std::string prefix); 181 std::string vk_print_vksubresourcelayout(const VkSubresourceLayout* pStruct, const std::string prefix); 182 std::string vk_print_vksurfacecapabilitieskhr(const VkSurfaceCapabilitiesKHR* pStruct, const std::string prefix); 183 std::string vk_print_vksurfaceformatkhr(const VkSurfaceFormatKHR* pStruct, const std::string prefix); 184 std::string vk_print_vkswapchaincreateinfokhr(const VkSwapchainCreateInfoKHR* pStruct, const std::string prefix); 185 std::string vk_print_vkvertexinputattributedescription(const VkVertexInputAttributeDescription* pStruct, const std::string prefix); 186 std::string vk_print_vkvertexinputbindingdescription(const VkVertexInputBindingDescription* pStruct, const std::string prefix); 187 std::string vk_print_vkviewport(const VkViewport* pStruct, const std::string prefix); 188 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 189 std::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 192 std::string vk_print_vkwin32surfacecreateinfokhr(const VkWin32SurfaceCreateInfoKHR* pStruct, const std::string prefix); 193 #endif //VK_USE_PLATFORM_WIN32_KHR 194 std::string vk_print_vkwritedescriptorset(const VkWriteDescriptorSet* pStruct, const std::string prefix); 195 #ifdef VK_USE_PLATFORM_XCB_KHR 196 std::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 199 std::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 205 std::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 235 std::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 271 std::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 320 std::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 336 std::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 352 std::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 485 std::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 505 std::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 564 std::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 609 std::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 654 std::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 693 std::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 720 std::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 781 std::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 799 std::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 826 std::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 857 std::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 892 std::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 938 std::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 981 std::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 1016 std::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 1029 std::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 1076 std::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 1121 std::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 1174 std::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 1213 std::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 1255 std::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 1295 std::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 1315 std::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 1333 std::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 1390 std::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 1406 std::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 1459 std::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 1498 std::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 1553 std::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 1659 std::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 1714 std::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 1734 std::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 1775 std::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 1800 std::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 1825 std::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 1906 std::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 1924 std::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 1973 std::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 2018 std::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 2067 std::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 2091 std::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 2113 std::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 2146 std::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 2179 std::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 2197 std::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 2217 std::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 2250 std::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 2270 std::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 2331 std::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 2513 std::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 2579 std::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 2634 std::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 2703 std::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 2734 std::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 2783 std::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 2838 std::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 2858 std::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 2880 std::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 2904 std::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 2955 std::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 3040 std::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 3090 std::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 3127 std::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 3162 std::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 3197 std::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 3215 std::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 3235 std::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 3254 std::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 3292 std::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 3310 std::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 3330 std::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 3454 std::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 3760 std::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 3814 std::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 3884 std::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 3908 std::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 3948 std::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 3966 std::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 4038 std::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 4099 std::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 4155 std::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 4190 std::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 4264 std::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 4307 std::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 4356 std::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 4387 std::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 4441 std::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 4476 std::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 4552 std::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 4628 std::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 4720 std::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 4740 std::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 4777 std::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 4806 std::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 4837 std::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 4902 std::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 4999 std::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 5046 std::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 5079 std::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 5116 std::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 5155 std::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 5182 std::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 5227 std::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 5266 std::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 5297 std::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 5336 std::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 5360 std::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 5404 std::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 5424 std::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 5444 std::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 5535 std::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 5563 std::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 5674 std::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 5698 std::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 5749 std::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 5762 std::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 5837 std::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 5857 std::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 5875 std::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 5902 std::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 5941 std::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 5979 std::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 6088 std::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 6127 std::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 6165 std::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 6175 std::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 6185 std::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 6192 std::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 }
