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 #889 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_vkdedicatedallocationbuffercreateinfonv(const VkDedicatedAllocationBufferCreateInfoNV* pStruct, const std::string prefix); 89 std::string vk_print_vkdedicatedallocationimagecreateinfonv(const VkDedicatedAllocationImageCreateInfoNV* pStruct, const std::string prefix); 90 std::string vk_print_vkdedicatedallocationmemoryallocateinfonv(const VkDedicatedAllocationMemoryAllocateInfoNV* pStruct, const std::string prefix); 91 std::string vk_print_vkdescriptorbufferinfo(const VkDescriptorBufferInfo* pStruct, const std::string prefix); 92 std::string vk_print_vkdescriptorimageinfo(const VkDescriptorImageInfo* pStruct, const std::string prefix); 93 std::string vk_print_vkdescriptorpoolcreateinfo(const VkDescriptorPoolCreateInfo* pStruct, const std::string prefix); 94 std::string vk_print_vkdescriptorpoolsize(const VkDescriptorPoolSize* pStruct, const std::string prefix); 95 std::string vk_print_vkdescriptorsetallocateinfo(const VkDescriptorSetAllocateInfo* pStruct, const std::string prefix); 96 std::string vk_print_vkdescriptorsetlayoutbinding(const VkDescriptorSetLayoutBinding* pStruct, const std::string prefix); 97 std::string vk_print_vkdescriptorsetlayoutcreateinfo(const VkDescriptorSetLayoutCreateInfo* pStruct, const std::string prefix); 98 std::string vk_print_vkdevicecreateinfo(const VkDeviceCreateInfo* pStruct, const std::string prefix); 99 std::string vk_print_vkdevicequeuecreateinfo(const VkDeviceQueueCreateInfo* pStruct, const std::string prefix); 100 std::string vk_print_vkdispatchindirectcommand(const VkDispatchIndirectCommand* pStruct, const std::string prefix); 101 std::string vk_print_vkdisplaymodecreateinfokhr(const VkDisplayModeCreateInfoKHR* pStruct, const std::string prefix); 102 std::string vk_print_vkdisplaymodeparameterskhr(const VkDisplayModeParametersKHR* pStruct, const std::string prefix); 103 std::string vk_print_vkdisplaymodepropertieskhr(const VkDisplayModePropertiesKHR* pStruct, const std::string prefix); 104 std::string vk_print_vkdisplayplanecapabilitieskhr(const VkDisplayPlaneCapabilitiesKHR* pStruct, const std::string prefix); 105 std::string vk_print_vkdisplayplanepropertieskhr(const VkDisplayPlanePropertiesKHR* pStruct, const std::string prefix); 106 std::string vk_print_vkdisplaypresentinfokhr(const VkDisplayPresentInfoKHR* pStruct, const std::string prefix); 107 std::string vk_print_vkdisplaypropertieskhr(const VkDisplayPropertiesKHR* pStruct, const std::string prefix); 108 std::string vk_print_vkdisplaysurfacecreateinfokhr(const VkDisplaySurfaceCreateInfoKHR* pStruct, const std::string prefix); 109 std::string vk_print_vkdrawindexedindirectcommand(const VkDrawIndexedIndirectCommand* pStruct, const std::string prefix); 110 std::string vk_print_vkdrawindirectcommand(const VkDrawIndirectCommand* pStruct, const std::string prefix); 111 std::string vk_print_vkeventcreateinfo(const VkEventCreateInfo* pStruct, const std::string prefix); 112 std::string vk_print_vkexportmemoryallocateinfonv(const VkExportMemoryAllocateInfoNV* pStruct, const std::string prefix); 113 #ifdef VK_USE_PLATFORM_WIN32_KHR 114 std::string vk_print_vkexportmemorywin32handleinfonv(const VkExportMemoryWin32HandleInfoNV* pStruct, const std::string prefix); 115 #endif //VK_USE_PLATFORM_WIN32_KHR 116 std::string vk_print_vkextensionproperties(const VkExtensionProperties* pStruct, const std::string prefix); 117 std::string vk_print_vkextent2d(const VkExtent2D* pStruct, const std::string prefix); 118 std::string vk_print_vkextent3d(const VkExtent3D* pStruct, const std::string prefix); 119 std::string vk_print_vkexternalimageformatpropertiesnv(const VkExternalImageFormatPropertiesNV* pStruct, const std::string prefix); 120 std::string vk_print_vkexternalmemoryimagecreateinfonv(const VkExternalMemoryImageCreateInfoNV* pStruct, const std::string prefix); 121 std::string vk_print_vkfencecreateinfo(const VkFenceCreateInfo* pStruct, const std::string prefix); 122 std::string vk_print_vkformatproperties(const VkFormatProperties* pStruct, const std::string prefix); 123 std::string vk_print_vkframebuffercreateinfo(const VkFramebufferCreateInfo* pStruct, const std::string prefix); 124 std::string vk_print_vkgraphicspipelinecreateinfo(const VkGraphicsPipelineCreateInfo* pStruct, const std::string prefix); 125 std::string vk_print_vkimageblit(const VkImageBlit* pStruct, const std::string prefix); 126 std::string vk_print_vkimagecopy(const VkImageCopy* pStruct, const std::string prefix); 127 std::string vk_print_vkimagecreateinfo(const VkImageCreateInfo* pStruct, const std::string prefix); 128 std::string vk_print_vkimageformatproperties(const VkImageFormatProperties* pStruct, const std::string prefix); 129 std::string vk_print_vkimagememorybarrier(const VkImageMemoryBarrier* pStruct, const std::string prefix); 130 std::string vk_print_vkimageresolve(const VkImageResolve* pStruct, const std::string prefix); 131 std::string vk_print_vkimagesubresource(const VkImageSubresource* pStruct, const std::string prefix); 132 std::string vk_print_vkimagesubresourcelayers(const VkImageSubresourceLayers* pStruct, const std::string prefix); 133 std::string vk_print_vkimagesubresourcerange(const VkImageSubresourceRange* pStruct, const std::string prefix); 134 std::string vk_print_vkimageviewcreateinfo(const VkImageViewCreateInfo* pStruct, const std::string prefix); 135 #ifdef VK_USE_PLATFORM_WIN32_KHR 136 std::string vk_print_vkimportmemorywin32handleinfonv(const VkImportMemoryWin32HandleInfoNV* pStruct, const std::string prefix); 137 #endif //VK_USE_PLATFORM_WIN32_KHR 138 std::string vk_print_vkinstancecreateinfo(const VkInstanceCreateInfo* pStruct, const std::string prefix); 139 std::string vk_print_vklayerproperties(const VkLayerProperties* pStruct, const std::string prefix); 140 std::string vk_print_vkmappedmemoryrange(const VkMappedMemoryRange* pStruct, const std::string prefix); 141 std::string vk_print_vkmemoryallocateinfo(const VkMemoryAllocateInfo* pStruct, const std::string prefix); 142 std::string vk_print_vkmemorybarrier(const VkMemoryBarrier* pStruct, const std::string prefix); 143 std::string vk_print_vkmemoryheap(const VkMemoryHeap* pStruct, const std::string prefix); 144 std::string vk_print_vkmemoryrequirements(const VkMemoryRequirements* pStruct, const std::string prefix); 145 std::string vk_print_vkmemorytype(const VkMemoryType* pStruct, const std::string prefix); 146 #ifdef VK_USE_PLATFORM_MIR_KHR 147 std::string vk_print_vkmirsurfacecreateinfokhr(const VkMirSurfaceCreateInfoKHR* pStruct, const std::string prefix); 148 #endif //VK_USE_PLATFORM_MIR_KHR 149 std::string vk_print_vkoffset2d(const VkOffset2D* pStruct, const std::string prefix); 150 std::string vk_print_vkoffset3d(const VkOffset3D* pStruct, const std::string prefix); 151 std::string vk_print_vkphysicaldevicefeatures(const VkPhysicalDeviceFeatures* pStruct, const std::string prefix); 152 std::string vk_print_vkphysicaldevicelimits(const VkPhysicalDeviceLimits* pStruct, const std::string prefix); 153 std::string vk_print_vkphysicaldevicememoryproperties(const VkPhysicalDeviceMemoryProperties* pStruct, const std::string prefix); 154 std::string vk_print_vkphysicaldeviceproperties(const VkPhysicalDeviceProperties* pStruct, const std::string prefix); 155 std::string vk_print_vkphysicaldevicesparseproperties(const VkPhysicalDeviceSparseProperties* pStruct, const std::string prefix); 156 std::string vk_print_vkpipelinecachecreateinfo(const VkPipelineCacheCreateInfo* pStruct, const std::string prefix); 157 std::string vk_print_vkpipelinecolorblendattachmentstate(const VkPipelineColorBlendAttachmentState* pStruct, const std::string prefix); 158 std::string vk_print_vkpipelinecolorblendstatecreateinfo(const VkPipelineColorBlendStateCreateInfo* pStruct, const std::string prefix); 159 std::string vk_print_vkpipelinedepthstencilstatecreateinfo(const VkPipelineDepthStencilStateCreateInfo* pStruct, const std::string prefix); 160 std::string vk_print_vkpipelinedynamicstatecreateinfo(const VkPipelineDynamicStateCreateInfo* pStruct, const std::string prefix); 161 std::string vk_print_vkpipelineinputassemblystatecreateinfo(const VkPipelineInputAssemblyStateCreateInfo* pStruct, const std::string prefix); 162 std::string vk_print_vkpipelinelayoutcreateinfo(const VkPipelineLayoutCreateInfo* pStruct, const std::string prefix); 163 std::string vk_print_vkpipelinemultisamplestatecreateinfo(const VkPipelineMultisampleStateCreateInfo* pStruct, const std::string prefix); 164 std::string vk_print_vkpipelinerasterizationstatecreateinfo(const VkPipelineRasterizationStateCreateInfo* pStruct, const std::string prefix); 165 std::string vk_print_vkpipelinerasterizationstaterasterizationorderamd(const VkPipelineRasterizationStateRasterizationOrderAMD* pStruct, const std::string prefix); 166 std::string vk_print_vkpipelineshaderstagecreateinfo(const VkPipelineShaderStageCreateInfo* pStruct, const std::string prefix); 167 std::string vk_print_vkpipelinetessellationstatecreateinfo(const VkPipelineTessellationStateCreateInfo* pStruct, const std::string prefix); 168 std::string vk_print_vkpipelinevertexinputstatecreateinfo(const VkPipelineVertexInputStateCreateInfo* pStruct, const std::string prefix); 169 std::string vk_print_vkpipelineviewportstatecreateinfo(const VkPipelineViewportStateCreateInfo* pStruct, const std::string prefix); 170 std::string vk_print_vkpresentinfokhr(const VkPresentInfoKHR* pStruct, const std::string prefix); 171 std::string vk_print_vkpushconstantrange(const VkPushConstantRange* pStruct, const std::string prefix); 172 std::string vk_print_vkquerypoolcreateinfo(const VkQueryPoolCreateInfo* pStruct, const std::string prefix); 173 std::string vk_print_vkqueuefamilyproperties(const VkQueueFamilyProperties* pStruct, const std::string prefix); 174 std::string vk_print_vkrect2d(const VkRect2D* pStruct, const std::string prefix); 175 std::string vk_print_vkrenderpassbegininfo(const VkRenderPassBeginInfo* pStruct, const std::string prefix); 176 std::string vk_print_vkrenderpasscreateinfo(const VkRenderPassCreateInfo* pStruct, const std::string prefix); 177 std::string vk_print_vksamplercreateinfo(const VkSamplerCreateInfo* pStruct, const std::string prefix); 178 std::string vk_print_vksemaphorecreateinfo(const VkSemaphoreCreateInfo* pStruct, const std::string prefix); 179 std::string vk_print_vkshadermodulecreateinfo(const VkShaderModuleCreateInfo* pStruct, const std::string prefix); 180 std::string vk_print_vksparsebuffermemorybindinfo(const VkSparseBufferMemoryBindInfo* pStruct, const std::string prefix); 181 std::string vk_print_vksparseimageformatproperties(const VkSparseImageFormatProperties* pStruct, const std::string prefix); 182 std::string vk_print_vksparseimagememorybind(const VkSparseImageMemoryBind* pStruct, const std::string prefix); 183 std::string vk_print_vksparseimagememorybindinfo(const VkSparseImageMemoryBindInfo* pStruct, const std::string prefix); 184 std::string vk_print_vksparseimagememoryrequirements(const VkSparseImageMemoryRequirements* pStruct, const std::string prefix); 185 std::string vk_print_vksparseimageopaquememorybindinfo(const VkSparseImageOpaqueMemoryBindInfo* pStruct, const std::string prefix); 186 std::string vk_print_vksparsememorybind(const VkSparseMemoryBind* pStruct, const std::string prefix); 187 std::string vk_print_vkspecializationinfo(const VkSpecializationInfo* pStruct, const std::string prefix); 188 std::string vk_print_vkspecializationmapentry(const VkSpecializationMapEntry* pStruct, const std::string prefix); 189 std::string vk_print_vkstencilopstate(const VkStencilOpState* pStruct, const std::string prefix); 190 std::string vk_print_vksubmitinfo(const VkSubmitInfo* pStruct, const std::string prefix); 191 std::string vk_print_vksubpassdependency(const VkSubpassDependency* pStruct, const std::string prefix); 192 std::string vk_print_vksubpassdescription(const VkSubpassDescription* pStruct, const std::string prefix); 193 std::string vk_print_vksubresourcelayout(const VkSubresourceLayout* pStruct, const std::string prefix); 194 std::string vk_print_vksurfacecapabilitieskhr(const VkSurfaceCapabilitiesKHR* pStruct, const std::string prefix); 195 std::string vk_print_vksurfaceformatkhr(const VkSurfaceFormatKHR* pStruct, const std::string prefix); 196 std::string vk_print_vkswapchaincreateinfokhr(const VkSwapchainCreateInfoKHR* pStruct, const std::string prefix); 197 std::string vk_print_vkvalidationflagsext(const VkValidationFlagsEXT* pStruct, const std::string prefix); 198 std::string vk_print_vkvertexinputattributedescription(const VkVertexInputAttributeDescription* pStruct, const std::string prefix); 199 std::string vk_print_vkvertexinputbindingdescription(const VkVertexInputBindingDescription* pStruct, const std::string prefix); 200 std::string vk_print_vkviewport(const VkViewport* pStruct, const std::string prefix); 201 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 202 std::string vk_print_vkwaylandsurfacecreateinfokhr(const VkWaylandSurfaceCreateInfoKHR* pStruct, const std::string prefix); 203 #endif //VK_USE_PLATFORM_WAYLAND_KHR 204 #ifdef VK_USE_PLATFORM_WIN32_KHR 205 std::string vk_print_vkwin32keyedmutexacquirereleaseinfonv(const VkWin32KeyedMutexAcquireReleaseInfoNV* pStruct, const std::string prefix); 206 #endif //VK_USE_PLATFORM_WIN32_KHR 207 #ifdef VK_USE_PLATFORM_WIN32_KHR 208 std::string vk_print_vkwin32surfacecreateinfokhr(const VkWin32SurfaceCreateInfoKHR* pStruct, const std::string prefix); 209 #endif //VK_USE_PLATFORM_WIN32_KHR 210 std::string vk_print_vkwritedescriptorset(const VkWriteDescriptorSet* pStruct, const std::string prefix); 211 #ifdef VK_USE_PLATFORM_XCB_KHR 212 std::string vk_print_vkxcbsurfacecreateinfokhr(const VkXcbSurfaceCreateInfoKHR* pStruct, const std::string prefix); 213 #endif //VK_USE_PLATFORM_XCB_KHR 214 #ifdef VK_USE_PLATFORM_XLIB_KHR 215 std::string vk_print_vkxlibsurfacecreateinfokhr(const VkXlibSurfaceCreateInfoKHR* pStruct, const std::string prefix); 216 #endif //VK_USE_PLATFORM_XLIB_KHR 217 218 219 // CODEGEN : file ../vk_helper.py line #897 220 // CODEGEN : file ../vk_helper.py line #907 221 std::string vk_print_vkallocationcallbacks(const VkAllocationCallbacks* pStruct, const std::string prefix) 222 { 223 // CODEGEN : file ../vk_helper.py line #913 224 using namespace StreamControl; 225 using namespace std; 226 string final_str; 227 string tmp_str; 228 string extra_indent = " " + prefix; 229 stringstream ss[6]; 230 // CODEGEN : file ../vk_helper.py line #1070 231 if (StreamControl::writeAddress) 232 ss[0] << "0x" << pStruct->pUserData; 233 else 234 ss[0].str("address"); 235 // CODEGEN : file ../vk_helper.py line #1086 236 ss[1] << "0x" << pStruct->pfnAllocation; 237 // CODEGEN : file ../vk_helper.py line #1086 238 ss[2] << "0x" << pStruct->pfnReallocation; 239 // CODEGEN : file ../vk_helper.py line #1086 240 ss[3] << "0x" << pStruct->pfnFree; 241 // CODEGEN : file ../vk_helper.py line #1086 242 ss[4] << "0x" << pStruct->pfnInternalAllocation; 243 // CODEGEN : file ../vk_helper.py line #1086 244 ss[5] << "0x" << pStruct->pfnInternalFree; 245 // CODEGEN : file ../vk_helper.py line #1113 246 final_str = final_str + prefix + "pUserData = " + ss[0].str() + "\n"; 247 final_str = final_str + prefix + "pfnAllocation = " + ss[1].str() + "\n"; 248 final_str = final_str + prefix + "pfnReallocation = " + ss[2].str() + "\n"; 249 final_str = final_str + prefix + "pfnFree = " + ss[3].str() + "\n"; 250 final_str = final_str + prefix + "pfnInternalAllocation = " + ss[4].str() + "\n"; 251 final_str = final_str + prefix + "pfnInternalFree = " + ss[5].str() + "\n"; 252 return final_str; 253 } 254 // CODEGEN : file ../vk_helper.py line #907 255 #ifdef VK_USE_PLATFORM_ANDROID_KHR 256 std::string vk_print_vkandroidsurfacecreateinfokhr(const VkAndroidSurfaceCreateInfoKHR* pStruct, const std::string prefix) 257 { 258 // CODEGEN : file ../vk_helper.py line #913 259 using namespace StreamControl; 260 using namespace std; 261 string final_str; 262 string tmp_str; 263 string extra_indent = " " + prefix; 264 stringstream ss[3]; 265 string stp_strs[1]; 266 // CODEGEN : file ../vk_helper.py line #1012 267 if (pStruct->pNext) { 268 // CODEGEN : file ../vk_helper.py line #1016 269 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 270 ss[0] << "0x" << &pStruct->pNext; 271 // CODEGEN : file ../vk_helper.py line #1028 272 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 273 ss[0].str(""); 274 } 275 else 276 stp_strs[0] = ""; 277 // CODEGEN : file ../vk_helper.py line #1070 278 if (StreamControl::writeAddress) 279 ss[0] << "0x" << pStruct->pNext; 280 else 281 ss[0].str("address"); 282 // CODEGEN : file ../vk_helper.py line #1086 283 ss[1] << "0x" << pStruct->flags; 284 // CODEGEN : file ../vk_helper.py line #1086 285 ss[2] << "0x" << pStruct->window; 286 // CODEGEN : file ../vk_helper.py line #1113 287 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 288 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 289 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 290 final_str = final_str + prefix + "window = " + ss[2].str() + "\n"; 291 final_str = final_str + stp_strs[0]; 292 return final_str; 293 } 294 #endif //VK_USE_PLATFORM_ANDROID_KHR 295 // CODEGEN : file ../vk_helper.py line #907 296 std::string vk_print_vkapplicationinfo(const VkApplicationInfo* pStruct, const std::string prefix) 297 { 298 // CODEGEN : file ../vk_helper.py line #913 299 using namespace StreamControl; 300 using namespace std; 301 string final_str; 302 string tmp_str; 303 string extra_indent = " " + prefix; 304 stringstream ss[6]; 305 string stp_strs[1]; 306 // CODEGEN : file ../vk_helper.py line #1012 307 if (pStruct->pNext) { 308 // CODEGEN : file ../vk_helper.py line #1016 309 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 310 ss[0] << "0x" << &pStruct->pNext; 311 // CODEGEN : file ../vk_helper.py line #1028 312 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 313 ss[0].str(""); 314 } 315 else 316 stp_strs[0] = ""; 317 // CODEGEN : file ../vk_helper.py line #1070 318 if (StreamControl::writeAddress) 319 ss[0] << "0x" << pStruct->pNext; 320 else 321 ss[0].str("address"); 322 // CODEGEN : file ../vk_helper.py line #1076 323 if (pStruct->pApplicationName != NULL) { 324 ss[1] << pStruct->pApplicationName; 325 } else { 326 ss[1] << ""; 327 } 328 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 329 ss[2] << pStruct->applicationVersion; 330 // CODEGEN : file ../vk_helper.py line #1076 331 if (pStruct->pEngineName != NULL) { 332 ss[3] << pStruct->pEngineName; 333 } else { 334 ss[3] << ""; 335 } 336 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 337 ss[4] << pStruct->engineVersion; 338 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 339 ss[5] << pStruct->apiVersion; 340 // CODEGEN : file ../vk_helper.py line #1113 341 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 342 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 343 final_str = final_str + prefix + "pApplicationName = " + ss[1].str() + "\n"; 344 final_str = final_str + prefix + "applicationVersion = " + ss[2].str() + "\n"; 345 final_str = final_str + prefix + "pEngineName = " + ss[3].str() + "\n"; 346 final_str = final_str + prefix + "engineVersion = " + ss[4].str() + "\n"; 347 final_str = final_str + prefix + "apiVersion = " + ss[5].str() + "\n"; 348 final_str = final_str + stp_strs[0]; 349 return final_str; 350 } 351 // CODEGEN : file ../vk_helper.py line #907 352 std::string vk_print_vkattachmentdescription(const VkAttachmentDescription* pStruct, const std::string prefix) 353 { 354 // CODEGEN : file ../vk_helper.py line #913 355 using namespace StreamControl; 356 using namespace std; 357 string final_str; 358 string tmp_str; 359 string extra_indent = " " + prefix; 360 stringstream ss[1]; 361 // CODEGEN : file ../vk_helper.py line #1086 362 ss[0] << "0x" << pStruct->flags; 363 // CODEGEN : file ../vk_helper.py line #1113 364 final_str = final_str + prefix + "flags = " + ss[0].str() + "\n"; 365 final_str = final_str + prefix + "format = " + string_VkFormat(pStruct->format) + "\n"; 366 final_str = final_str + prefix + "samples = " + string_VkSampleCountFlagBits(pStruct->samples) + "\n"; 367 final_str = final_str + prefix + "loadOp = " + string_VkAttachmentLoadOp(pStruct->loadOp) + "\n"; 368 final_str = final_str + prefix + "storeOp = " + string_VkAttachmentStoreOp(pStruct->storeOp) + "\n"; 369 final_str = final_str + prefix + "stencilLoadOp = " + string_VkAttachmentLoadOp(pStruct->stencilLoadOp) + "\n"; 370 final_str = final_str + prefix + "stencilStoreOp = " + string_VkAttachmentStoreOp(pStruct->stencilStoreOp) + "\n"; 371 final_str = final_str + prefix + "initialLayout = " + string_VkImageLayout(pStruct->initialLayout) + "\n"; 372 final_str = final_str + prefix + "finalLayout = " + string_VkImageLayout(pStruct->finalLayout) + "\n"; 373 return final_str; 374 } 375 // CODEGEN : file ../vk_helper.py line #907 376 std::string vk_print_vkattachmentreference(const VkAttachmentReference* pStruct, const std::string prefix) 377 { 378 // CODEGEN : file ../vk_helper.py line #913 379 using namespace StreamControl; 380 using namespace std; 381 string final_str; 382 string tmp_str; 383 string extra_indent = " " + prefix; 384 stringstream ss[1]; 385 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 386 ss[0] << pStruct->attachment; 387 // CODEGEN : file ../vk_helper.py line #1113 388 final_str = final_str + prefix + "attachment = " + ss[0].str() + "\n"; 389 final_str = final_str + prefix + "layout = " + string_VkImageLayout(pStruct->layout) + "\n"; 390 return final_str; 391 } 392 // CODEGEN : file ../vk_helper.py line #907 393 std::string vk_print_vkbindsparseinfo(const VkBindSparseInfo* pStruct, const std::string prefix) 394 { 395 // CODEGEN : file ../vk_helper.py line #913 396 using namespace StreamControl; 397 using namespace std; 398 string final_str; 399 string tmp_str; 400 string extra_indent = " " + prefix; 401 stringstream ss[11]; 402 string stp_strs[6]; 403 // CODEGEN : file ../vk_helper.py line #1012 404 if (pStruct->pNext) { 405 // CODEGEN : file ../vk_helper.py line #1016 406 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 407 ss[0] << "0x" << &pStruct->pNext; 408 // CODEGEN : file ../vk_helper.py line #1028 409 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 410 ss[0].str(""); 411 } 412 else 413 stp_strs[0] = ""; 414 // CODEGEN : file ../vk_helper.py line #932 415 // CODEGEN : file ../vk_helper.py line #934 416 // CODEGEN : file ../vk_helper.py line #939 417 stp_strs[1] = ""; 418 stringstream index_ss; 419 if (pStruct->pWaitSemaphores) { 420 for (uint32_t i = 0; i < pStruct->waitSemaphoreCount; i++) { 421 index_ss.str(""); 422 index_ss << i; 423 // CODEGEN : file ../vk_helper.py line #990 424 ss[1] << "0x" << pStruct->pWaitSemaphores[i]; 425 stp_strs[1] += " " + prefix + "pWaitSemaphores[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 426 // CODEGEN : file ../vk_helper.py line #1000 427 ss[1].str(""); 428 } 429 } 430 // CODEGEN : file ../vk_helper.py line #932 431 // CODEGEN : file ../vk_helper.py line #934 432 // CODEGEN : file ../vk_helper.py line #939 433 stp_strs[2] = ""; 434 if (pStruct->pBufferBinds) { 435 for (uint32_t i = 0; i < pStruct->bufferBindCount; i++) { 436 index_ss.str(""); 437 index_ss << i; 438 // CODEGEN : file ../vk_helper.py line #980 439 ss[2] << "0x" << &pStruct->pBufferBinds[i]; 440 tmp_str = vk_print_vksparsebuffermemorybindinfo(&pStruct->pBufferBinds[i], extra_indent); 441 // CODEGEN : file ../vk_helper.py line #984 442 stp_strs[2] += " " + prefix + "pBufferBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 443 // CODEGEN : file ../vk_helper.py line #1000 444 ss[2].str(""); 445 } 446 } 447 // CODEGEN : file ../vk_helper.py line #932 448 // CODEGEN : file ../vk_helper.py line #934 449 // CODEGEN : file ../vk_helper.py line #939 450 stp_strs[3] = ""; 451 if (pStruct->pImageOpaqueBinds) { 452 for (uint32_t i = 0; i < pStruct->imageOpaqueBindCount; i++) { 453 index_ss.str(""); 454 index_ss << i; 455 // CODEGEN : file ../vk_helper.py line #980 456 ss[3] << "0x" << &pStruct->pImageOpaqueBinds[i]; 457 tmp_str = vk_print_vksparseimageopaquememorybindinfo(&pStruct->pImageOpaqueBinds[i], extra_indent); 458 // CODEGEN : file ../vk_helper.py line #984 459 stp_strs[3] += " " + prefix + "pImageOpaqueBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 460 // CODEGEN : file ../vk_helper.py line #1000 461 ss[3].str(""); 462 } 463 } 464 // CODEGEN : file ../vk_helper.py line #932 465 // CODEGEN : file ../vk_helper.py line #934 466 // CODEGEN : file ../vk_helper.py line #939 467 stp_strs[4] = ""; 468 if (pStruct->pImageBinds) { 469 for (uint32_t i = 0; i < pStruct->imageBindCount; i++) { 470 index_ss.str(""); 471 index_ss << i; 472 // CODEGEN : file ../vk_helper.py line #980 473 ss[4] << "0x" << &pStruct->pImageBinds[i]; 474 tmp_str = vk_print_vksparseimagememorybindinfo(&pStruct->pImageBinds[i], extra_indent); 475 // CODEGEN : file ../vk_helper.py line #984 476 stp_strs[4] += " " + prefix + "pImageBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 477 // CODEGEN : file ../vk_helper.py line #1000 478 ss[4].str(""); 479 } 480 } 481 // CODEGEN : file ../vk_helper.py line #932 482 // CODEGEN : file ../vk_helper.py line #934 483 // CODEGEN : file ../vk_helper.py line #939 484 stp_strs[5] = ""; 485 if (pStruct->pSignalSemaphores) { 486 for (uint32_t i = 0; i < pStruct->signalSemaphoreCount; i++) { 487 index_ss.str(""); 488 index_ss << i; 489 // CODEGEN : file ../vk_helper.py line #990 490 ss[5] << "0x" << pStruct->pSignalSemaphores[i]; 491 stp_strs[5] += " " + prefix + "pSignalSemaphores[" + index_ss.str() + "].handle = " + ss[5].str() + "\n"; 492 // CODEGEN : file ../vk_helper.py line #1000 493 ss[5].str(""); 494 } 495 } 496 // CODEGEN : file ../vk_helper.py line #1070 497 if (StreamControl::writeAddress) 498 ss[0] << "0x" << pStruct->pNext; 499 else 500 ss[0].str("address"); 501 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 502 ss[1] << pStruct->waitSemaphoreCount; 503 // CODEGEN : file ../vk_helper.py line #1061 504 ss[2] << "0x" << (void*)pStruct->pWaitSemaphores; 505 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 506 ss[3] << "0x" << pStruct->bufferBindCount; 507 // CODEGEN : file ../vk_helper.py line #1061 508 ss[4] << "0x" << (void*)pStruct->pBufferBinds; 509 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 510 ss[5] << pStruct->imageOpaqueBindCount; 511 // CODEGEN : file ../vk_helper.py line #1061 512 ss[6] << "0x" << (void*)pStruct->pImageOpaqueBinds; 513 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 514 ss[7] << pStruct->imageBindCount; 515 // CODEGEN : file ../vk_helper.py line #1061 516 ss[8] << "0x" << (void*)pStruct->pImageBinds; 517 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 518 ss[9] << pStruct->signalSemaphoreCount; 519 // CODEGEN : file ../vk_helper.py line #1061 520 ss[10] << "0x" << (void*)pStruct->pSignalSemaphores; 521 // CODEGEN : file ../vk_helper.py line #1113 522 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 523 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 524 final_str = final_str + prefix + "waitSemaphoreCount = " + ss[1].str() + "\n"; 525 final_str = final_str + prefix + "pWaitSemaphores = " + ss[2].str() + "\n"; 526 final_str = final_str + prefix + "bufferBindCount = " + ss[3].str() + "\n"; 527 final_str = final_str + prefix + "pBufferBinds = " + ss[4].str() + "\n"; 528 final_str = final_str + prefix + "imageOpaqueBindCount = " + ss[5].str() + "\n"; 529 final_str = final_str + prefix + "pImageOpaqueBinds = " + ss[6].str() + "\n"; 530 final_str = final_str + prefix + "imageBindCount = " + ss[7].str() + "\n"; 531 final_str = final_str + prefix + "pImageBinds = " + ss[8].str() + "\n"; 532 final_str = final_str + prefix + "signalSemaphoreCount = " + ss[9].str() + "\n"; 533 final_str = final_str + prefix + "pSignalSemaphores = " + ss[10].str() + "\n"; 534 final_str = final_str + stp_strs[5] + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 535 return final_str; 536 } 537 // CODEGEN : file ../vk_helper.py line #907 538 std::string vk_print_vkbuffercopy(const VkBufferCopy* pStruct, const std::string prefix) 539 { 540 // CODEGEN : file ../vk_helper.py line #913 541 using namespace StreamControl; 542 using namespace std; 543 string final_str; 544 string tmp_str; 545 string extra_indent = " " + prefix; 546 stringstream ss[3]; 547 // CODEGEN : file ../vk_helper.py line #1086 548 ss[0] << "0x" << pStruct->srcOffset; 549 // CODEGEN : file ../vk_helper.py line #1086 550 ss[1] << "0x" << pStruct->dstOffset; 551 // CODEGEN : file ../vk_helper.py line #1086 552 ss[2] << "0x" << pStruct->size; 553 // CODEGEN : file ../vk_helper.py line #1113 554 final_str = final_str + prefix + "srcOffset = " + ss[0].str() + "\n"; 555 final_str = final_str + prefix + "dstOffset = " + ss[1].str() + "\n"; 556 final_str = final_str + prefix + "size = " + ss[2].str() + "\n"; 557 return final_str; 558 } 559 // CODEGEN : file ../vk_helper.py line #907 560 std::string vk_print_vkbuffercreateinfo(const VkBufferCreateInfo* pStruct, const std::string prefix) 561 { 562 // CODEGEN : file ../vk_helper.py line #913 563 using namespace StreamControl; 564 using namespace std; 565 string final_str; 566 string tmp_str; 567 string extra_indent = " " + prefix; 568 stringstream ss[6]; 569 string stp_strs[2]; 570 // CODEGEN : file ../vk_helper.py line #1012 571 if (pStruct->pNext) { 572 // CODEGEN : file ../vk_helper.py line #1016 573 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 574 ss[0] << "0x" << &pStruct->pNext; 575 // CODEGEN : file ../vk_helper.py line #1028 576 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 577 ss[0].str(""); 578 } 579 else 580 stp_strs[0] = ""; 581 // CODEGEN : file ../vk_helper.py line #932 582 // CODEGEN : file ../vk_helper.py line #934 583 // CODEGEN : file ../vk_helper.py line #939 584 stp_strs[1] = ""; 585 stringstream index_ss; 586 if (pStruct->sharingMode == VK_SHARING_MODE_CONCURRENT) { 587 if (pStruct->pQueueFamilyIndices) { 588 for (uint32_t i = 0; i < pStruct->queueFamilyIndexCount; i++) { 589 index_ss.str(""); 590 index_ss << i; 591 // CODEGEN : file ../vk_helper.py line #990 592 ss[1] << "0x" << pStruct->pQueueFamilyIndices[i]; 593 stp_strs[1] += " " + prefix + "pQueueFamilyIndices[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 594 // CODEGEN : file ../vk_helper.py line #1000 595 ss[1].str(""); 596 } 597 } 598 } 599 // CODEGEN : file ../vk_helper.py line #1070 600 if (StreamControl::writeAddress) 601 ss[0] << "0x" << pStruct->pNext; 602 else 603 ss[0].str("address"); 604 // CODEGEN : file ../vk_helper.py line #1086 605 ss[1] << "0x" << pStruct->flags; 606 // CODEGEN : file ../vk_helper.py line #1086 607 ss[2] << "0x" << pStruct->size; 608 // CODEGEN : file ../vk_helper.py line #1086 609 ss[3] << "0x" << pStruct->usage; 610 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 611 ss[4] << pStruct->queueFamilyIndexCount; 612 // CODEGEN : file ../vk_helper.py line #1061 613 ss[5] << "0x" << (void*)pStruct->pQueueFamilyIndices; 614 // CODEGEN : file ../vk_helper.py line #1113 615 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 616 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 617 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 618 final_str = final_str + prefix + "size = " + ss[2].str() + "\n"; 619 final_str = final_str + prefix + "usage = " + ss[3].str() + "\n"; 620 final_str = final_str + prefix + "sharingMode = " + string_VkSharingMode(pStruct->sharingMode) + "\n"; 621 final_str = final_str + prefix + "queueFamilyIndexCount = " + ss[4].str() + "\n"; 622 final_str = final_str + prefix + "pQueueFamilyIndices = " + ss[5].str() + "\n"; 623 final_str = final_str + stp_strs[1] + stp_strs[0]; 624 return final_str; 625 } 626 // CODEGEN : file ../vk_helper.py line #907 627 std::string vk_print_vkbufferimagecopy(const VkBufferImageCopy* pStruct, const std::string prefix) 628 { 629 // CODEGEN : file ../vk_helper.py line #913 630 using namespace StreamControl; 631 using namespace std; 632 string final_str; 633 string tmp_str; 634 string extra_indent = " " + prefix; 635 stringstream ss[6]; 636 string stp_strs[3]; 637 // CODEGEN : file ../vk_helper.py line #1038 638 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->imageSubresource, extra_indent); 639 ss[0] << "0x" << &pStruct->imageSubresource; 640 stp_strs[0] = " " + prefix + "imageSubresource (addr)\n" + tmp_str; 641 // CODEGEN : file ../vk_helper.py line #1043 642 ss[0].str(""); 643 // CODEGEN : file ../vk_helper.py line #1038 644 tmp_str = vk_print_vkoffset3d(&pStruct->imageOffset, extra_indent); 645 ss[1] << "0x" << &pStruct->imageOffset; 646 stp_strs[1] = " " + prefix + "imageOffset (addr)\n" + tmp_str; 647 // CODEGEN : file ../vk_helper.py line #1043 648 ss[1].str(""); 649 // CODEGEN : file ../vk_helper.py line #1038 650 tmp_str = vk_print_vkextent3d(&pStruct->imageExtent, extra_indent); 651 ss[2] << "0x" << &pStruct->imageExtent; 652 stp_strs[2] = " " + prefix + "imageExtent (addr)\n" + tmp_str; 653 // CODEGEN : file ../vk_helper.py line #1043 654 ss[2].str(""); 655 // CODEGEN : file ../vk_helper.py line #1086 656 ss[0] << "0x" << pStruct->bufferOffset; 657 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 658 ss[1] << "0x" << pStruct->bufferRowLength; 659 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 660 ss[2] << "0x" << pStruct->bufferImageHeight; 661 // CODEGEN : file ../vk_helper.py line #1055 662 ss[3].str("addr"); 663 // CODEGEN : file ../vk_helper.py line #1055 664 ss[4].str("addr"); 665 // CODEGEN : file ../vk_helper.py line #1055 666 ss[5].str("addr"); 667 // CODEGEN : file ../vk_helper.py line #1113 668 final_str = final_str + prefix + "bufferOffset = " + ss[0].str() + "\n"; 669 final_str = final_str + prefix + "bufferRowLength = " + ss[1].str() + "\n"; 670 final_str = final_str + prefix + "bufferImageHeight = " + ss[2].str() + "\n"; 671 final_str = final_str + prefix + "imageSubresource = " + ss[3].str() + "\n"; 672 final_str = final_str + prefix + "imageOffset = " + ss[4].str() + "\n"; 673 final_str = final_str + prefix + "imageExtent = " + ss[5].str() + "\n"; 674 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 675 return final_str; 676 } 677 // CODEGEN : file ../vk_helper.py line #907 678 std::string vk_print_vkbuffermemorybarrier(const VkBufferMemoryBarrier* pStruct, const std::string prefix) 679 { 680 // CODEGEN : file ../vk_helper.py line #913 681 using namespace StreamControl; 682 using namespace std; 683 string final_str; 684 string tmp_str; 685 string extra_indent = " " + prefix; 686 stringstream ss[8]; 687 string stp_strs[1]; 688 // CODEGEN : file ../vk_helper.py line #1012 689 if (pStruct->pNext) { 690 // CODEGEN : file ../vk_helper.py line #1016 691 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 692 ss[0] << "0x" << &pStruct->pNext; 693 // CODEGEN : file ../vk_helper.py line #1028 694 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 695 ss[0].str(""); 696 } 697 else 698 stp_strs[0] = ""; 699 // CODEGEN : file ../vk_helper.py line #1070 700 if (StreamControl::writeAddress) 701 ss[0] << "0x" << pStruct->pNext; 702 else 703 ss[0].str("address"); 704 // CODEGEN : file ../vk_helper.py line #1086 705 ss[1] << "0x" << pStruct->srcAccessMask; 706 // CODEGEN : file ../vk_helper.py line #1086 707 ss[2] << "0x" << pStruct->dstAccessMask; 708 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 709 ss[3] << pStruct->srcQueueFamilyIndex; 710 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 711 ss[4] << pStruct->dstQueueFamilyIndex; 712 // CODEGEN : file ../vk_helper.py line #1086 713 ss[5] << "0x" << pStruct->buffer; 714 // CODEGEN : file ../vk_helper.py line #1086 715 ss[6] << "0x" << pStruct->offset; 716 // CODEGEN : file ../vk_helper.py line #1086 717 ss[7] << "0x" << pStruct->size; 718 // CODEGEN : file ../vk_helper.py line #1113 719 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 720 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 721 final_str = final_str + prefix + "srcAccessMask = " + ss[1].str() + "\n"; 722 final_str = final_str + prefix + "dstAccessMask = " + ss[2].str() + "\n"; 723 final_str = final_str + prefix + "srcQueueFamilyIndex = " + ss[3].str() + "\n"; 724 final_str = final_str + prefix + "dstQueueFamilyIndex = " + ss[4].str() + "\n"; 725 final_str = final_str + prefix + "buffer = " + ss[5].str() + "\n"; 726 final_str = final_str + prefix + "offset = " + ss[6].str() + "\n"; 727 final_str = final_str + prefix + "size = " + ss[7].str() + "\n"; 728 final_str = final_str + stp_strs[0]; 729 return final_str; 730 } 731 // CODEGEN : file ../vk_helper.py line #907 732 std::string vk_print_vkbufferviewcreateinfo(const VkBufferViewCreateInfo* pStruct, const std::string prefix) 733 { 734 // CODEGEN : file ../vk_helper.py line #913 735 using namespace StreamControl; 736 using namespace std; 737 string final_str; 738 string tmp_str; 739 string extra_indent = " " + prefix; 740 stringstream ss[5]; 741 string stp_strs[1]; 742 // CODEGEN : file ../vk_helper.py line #1012 743 if (pStruct->pNext) { 744 // CODEGEN : file ../vk_helper.py line #1016 745 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 746 ss[0] << "0x" << &pStruct->pNext; 747 // CODEGEN : file ../vk_helper.py line #1028 748 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 749 ss[0].str(""); 750 } 751 else 752 stp_strs[0] = ""; 753 // CODEGEN : file ../vk_helper.py line #1070 754 if (StreamControl::writeAddress) 755 ss[0] << "0x" << pStruct->pNext; 756 else 757 ss[0].str("address"); 758 // CODEGEN : file ../vk_helper.py line #1086 759 ss[1] << "0x" << pStruct->flags; 760 // CODEGEN : file ../vk_helper.py line #1086 761 ss[2] << "0x" << pStruct->buffer; 762 // CODEGEN : file ../vk_helper.py line #1086 763 ss[3] << "0x" << pStruct->offset; 764 // CODEGEN : file ../vk_helper.py line #1086 765 ss[4] << "0x" << pStruct->range; 766 // CODEGEN : file ../vk_helper.py line #1113 767 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 768 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 769 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 770 final_str = final_str + prefix + "buffer = " + ss[2].str() + "\n"; 771 final_str = final_str + prefix + "format = " + string_VkFormat(pStruct->format) + "\n"; 772 final_str = final_str + prefix + "offset = " + ss[3].str() + "\n"; 773 final_str = final_str + prefix + "range = " + ss[4].str() + "\n"; 774 final_str = final_str + stp_strs[0]; 775 return final_str; 776 } 777 // CODEGEN : file ../vk_helper.py line #907 778 std::string vk_print_vkclearattachment(const VkClearAttachment* pStruct, const std::string prefix) 779 { 780 // CODEGEN : file ../vk_helper.py line #913 781 using namespace StreamControl; 782 using namespace std; 783 string final_str; 784 string tmp_str; 785 string extra_indent = " " + prefix; 786 stringstream ss[3]; 787 string stp_strs[1]; 788 // CODEGEN : file ../vk_helper.py line #1038 789 tmp_str = vk_print_vkclearvalue(&pStruct->clearValue, extra_indent); 790 ss[0] << "0x" << &pStruct->clearValue; 791 stp_strs[0] = " " + prefix + "clearValue (addr)\n" + tmp_str; 792 // CODEGEN : file ../vk_helper.py line #1043 793 ss[0].str(""); 794 // CODEGEN : file ../vk_helper.py line #1086 795 ss[0] << "0x" << pStruct->aspectMask; 796 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 797 ss[1] << pStruct->colorAttachment; 798 // CODEGEN : file ../vk_helper.py line #1055 799 ss[2].str("addr"); 800 // CODEGEN : file ../vk_helper.py line #1113 801 final_str = final_str + prefix + "aspectMask = " + ss[0].str() + "\n"; 802 final_str = final_str + prefix + "colorAttachment = " + ss[1].str() + "\n"; 803 final_str = final_str + prefix + "clearValue = " + ss[2].str() + "\n"; 804 final_str = final_str + stp_strs[0]; 805 return final_str; 806 } 807 // CODEGEN : file ../vk_helper.py line #907 808 std::string vk_print_vkclearcolorvalue(const VkClearColorValue* pStruct, const std::string prefix) 809 { 810 // CODEGEN : file ../vk_helper.py line #913 811 using namespace StreamControl; 812 using namespace std; 813 string final_str; 814 string tmp_str; 815 string extra_indent = " " + prefix; 816 stringstream ss[3]; 817 string stp_strs[3]; 818 // CODEGEN : file ../vk_helper.py line #932 819 // CODEGEN : file ../vk_helper.py line #937 820 // CODEGEN : file ../vk_helper.py line #939 821 stp_strs[0] = ""; 822 stringstream index_ss; 823 for (uint32_t i = 0; i < 4; i++) { 824 index_ss.str(""); 825 index_ss << i; 826 // CODEGEN : file ../vk_helper.py line #990 827 ss[0] << pStruct->float32[i]; 828 stp_strs[0] += " " + prefix + "float32[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 829 // CODEGEN : file ../vk_helper.py line #1000 830 ss[0].str(""); 831 } 832 // CODEGEN : file ../vk_helper.py line #932 833 // CODEGEN : file ../vk_helper.py line #937 834 // CODEGEN : file ../vk_helper.py line #939 835 stp_strs[1] = ""; 836 for (uint32_t i = 0; i < 4; i++) { 837 index_ss.str(""); 838 index_ss << i; 839 // CODEGEN : file ../vk_helper.py line #990 840 ss[1] << pStruct->int32[i]; 841 stp_strs[1] += " " + prefix + "int32[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 842 // CODEGEN : file ../vk_helper.py line #1000 843 ss[1].str(""); 844 } 845 // CODEGEN : file ../vk_helper.py line #932 846 // CODEGEN : file ../vk_helper.py line #937 847 // CODEGEN : file ../vk_helper.py line #939 848 stp_strs[2] = ""; 849 for (uint32_t i = 0; i < 4; i++) { 850 index_ss.str(""); 851 index_ss << i; 852 // CODEGEN : file ../vk_helper.py line #990 853 ss[2] << pStruct->uint32[i]; 854 stp_strs[2] += " " + prefix + "uint32[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 855 // CODEGEN : file ../vk_helper.py line #1000 856 ss[2].str(""); 857 } 858 // CODEGEN : file ../vk_helper.py line #1061 859 ss[0] << "0x" << (void*)pStruct->float32; 860 // CODEGEN : file ../vk_helper.py line #1061 861 ss[1] << "0x" << (void*)pStruct->int32; 862 // CODEGEN : file ../vk_helper.py line #1061 863 ss[2] << "0x" << (void*)pStruct->uint32; 864 // CODEGEN : file ../vk_helper.py line #1113 865 final_str = final_str + prefix + "float32 = " + ss[0].str() + "\n"; 866 final_str = final_str + prefix + "int32 = " + ss[1].str() + "\n"; 867 final_str = final_str + prefix + "uint32 = " + ss[2].str() + "\n"; 868 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 869 return final_str; 870 } 871 // CODEGEN : file ../vk_helper.py line #907 872 std::string vk_print_vkcleardepthstencilvalue(const VkClearDepthStencilValue* pStruct, const std::string prefix) 873 { 874 // CODEGEN : file ../vk_helper.py line #913 875 using namespace StreamControl; 876 using namespace std; 877 string final_str; 878 string tmp_str; 879 string extra_indent = " " + prefix; 880 stringstream ss[2]; 881 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 882 ss[0] << pStruct->depth; 883 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 884 ss[1] << pStruct->stencil; 885 // CODEGEN : file ../vk_helper.py line #1113 886 final_str = final_str + prefix + "depth = " + ss[0].str() + "\n"; 887 final_str = final_str + prefix + "stencil = " + ss[1].str() + "\n"; 888 return final_str; 889 } 890 // CODEGEN : file ../vk_helper.py line #907 891 std::string vk_print_vkclearrect(const VkClearRect* pStruct, const std::string prefix) 892 { 893 // CODEGEN : file ../vk_helper.py line #913 894 using namespace StreamControl; 895 using namespace std; 896 string final_str; 897 string tmp_str; 898 string extra_indent = " " + prefix; 899 stringstream ss[3]; 900 string stp_strs[1]; 901 // CODEGEN : file ../vk_helper.py line #1038 902 tmp_str = vk_print_vkrect2d(&pStruct->rect, extra_indent); 903 ss[0] << "0x" << &pStruct->rect; 904 stp_strs[0] = " " + prefix + "rect (addr)\n" + tmp_str; 905 // CODEGEN : file ../vk_helper.py line #1043 906 ss[0].str(""); 907 // CODEGEN : file ../vk_helper.py line #1055 908 ss[0].str("addr"); 909 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 910 ss[1] << pStruct->baseArrayLayer; 911 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 912 ss[2] << pStruct->layerCount; 913 // CODEGEN : file ../vk_helper.py line #1113 914 final_str = final_str + prefix + "rect = " + ss[0].str() + "\n"; 915 final_str = final_str + prefix + "baseArrayLayer = " + ss[1].str() + "\n"; 916 final_str = final_str + prefix + "layerCount = " + ss[2].str() + "\n"; 917 final_str = final_str + stp_strs[0]; 918 return final_str; 919 } 920 // CODEGEN : file ../vk_helper.py line #907 921 std::string vk_print_vkclearvalue(const VkClearValue* pStruct, const std::string prefix) 922 { 923 // CODEGEN : file ../vk_helper.py line #913 924 using namespace StreamControl; 925 using namespace std; 926 string final_str; 927 string tmp_str; 928 string extra_indent = " " + prefix; 929 stringstream ss[2]; 930 string stp_strs[2]; 931 // CODEGEN : file ../vk_helper.py line #1038 932 tmp_str = vk_print_vkclearcolorvalue(&pStruct->color, extra_indent); 933 ss[0] << "0x" << &pStruct->color; 934 stp_strs[0] = " " + prefix + "color (addr)\n" + tmp_str; 935 // CODEGEN : file ../vk_helper.py line #1043 936 ss[0].str(""); 937 // CODEGEN : file ../vk_helper.py line #1038 938 tmp_str = vk_print_vkcleardepthstencilvalue(&pStruct->depthStencil, extra_indent); 939 ss[1] << "0x" << &pStruct->depthStencil; 940 stp_strs[1] = " " + prefix + "depthStencil (addr)\n" + tmp_str; 941 // CODEGEN : file ../vk_helper.py line #1043 942 ss[1].str(""); 943 // CODEGEN : file ../vk_helper.py line #1055 944 ss[0].str("addr"); 945 // CODEGEN : file ../vk_helper.py line #1055 946 ss[1].str("addr"); 947 // CODEGEN : file ../vk_helper.py line #1113 948 final_str = final_str + prefix + "color = " + ss[0].str() + "\n"; 949 final_str = final_str + prefix + "depthStencil = " + ss[1].str() + "\n"; 950 final_str = final_str + stp_strs[1] + stp_strs[0]; 951 return final_str; 952 } 953 // CODEGEN : file ../vk_helper.py line #907 954 std::string vk_print_vkcommandbufferallocateinfo(const VkCommandBufferAllocateInfo* pStruct, const std::string prefix) 955 { 956 // CODEGEN : file ../vk_helper.py line #913 957 using namespace StreamControl; 958 using namespace std; 959 string final_str; 960 string tmp_str; 961 string extra_indent = " " + prefix; 962 stringstream ss[3]; 963 string stp_strs[1]; 964 // CODEGEN : file ../vk_helper.py line #1012 965 if (pStruct->pNext) { 966 // CODEGEN : file ../vk_helper.py line #1016 967 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 968 ss[0] << "0x" << &pStruct->pNext; 969 // CODEGEN : file ../vk_helper.py line #1028 970 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 971 ss[0].str(""); 972 } 973 else 974 stp_strs[0] = ""; 975 // CODEGEN : file ../vk_helper.py line #1070 976 if (StreamControl::writeAddress) 977 ss[0] << "0x" << pStruct->pNext; 978 else 979 ss[0].str("address"); 980 // CODEGEN : file ../vk_helper.py line #1086 981 ss[1] << "0x" << pStruct->commandPool; 982 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 983 ss[2] << "0x" << pStruct->commandBufferCount; 984 // CODEGEN : file ../vk_helper.py line #1113 985 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 986 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 987 final_str = final_str + prefix + "commandPool = " + ss[1].str() + "\n"; 988 final_str = final_str + prefix + "level = " + string_VkCommandBufferLevel(pStruct->level) + "\n"; 989 final_str = final_str + prefix + "commandBufferCount = " + ss[2].str() + "\n"; 990 final_str = final_str + stp_strs[0]; 991 return final_str; 992 } 993 // CODEGEN : file ../vk_helper.py line #907 994 std::string vk_print_vkcommandbufferbegininfo(const VkCommandBufferBeginInfo* pStruct, const std::string prefix) 995 { 996 // CODEGEN : file ../vk_helper.py line #913 997 using namespace StreamControl; 998 using namespace std; 999 string final_str; 1000 string tmp_str; 1001 string extra_indent = " " + prefix; 1002 stringstream ss[3]; 1003 string stp_strs[2]; 1004 // CODEGEN : file ../vk_helper.py line #1012 1005 if (pStruct->pNext) { 1006 // CODEGEN : file ../vk_helper.py line #1016 1007 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1008 ss[0] << "0x" << &pStruct->pNext; 1009 // CODEGEN : file ../vk_helper.py line #1028 1010 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1011 ss[0].str(""); 1012 } 1013 else 1014 stp_strs[0] = ""; 1015 // CODEGEN : file ../vk_helper.py line #1012 1016 if (pStruct->pInheritanceInfo) { 1017 // CODEGEN : file ../vk_helper.py line #1024 1018 tmp_str = vk_print_vkcommandbufferinheritanceinfo(pStruct->pInheritanceInfo, extra_indent); 1019 ss[1] << "0x" << &pStruct->pInheritanceInfo; 1020 // CODEGEN : file ../vk_helper.py line #1028 1021 stp_strs[1] = " " + prefix + "pInheritanceInfo (addr)\n" + tmp_str; 1022 ss[1].str(""); 1023 } 1024 else 1025 stp_strs[1] = ""; 1026 // CODEGEN : file ../vk_helper.py line #1070 1027 if (StreamControl::writeAddress) 1028 ss[0] << "0x" << pStruct->pNext; 1029 else 1030 ss[0].str("address"); 1031 // CODEGEN : file ../vk_helper.py line #1086 1032 ss[1] << "0x" << pStruct->flags; 1033 // CODEGEN : file ../vk_helper.py line #1086 1034 ss[2] << "0x" << pStruct->pInheritanceInfo; 1035 // CODEGEN : file ../vk_helper.py line #1113 1036 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1037 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1038 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 1039 final_str = final_str + prefix + "pInheritanceInfo = " + ss[2].str() + "\n"; 1040 final_str = final_str + stp_strs[1] + stp_strs[0]; 1041 return final_str; 1042 } 1043 // CODEGEN : file ../vk_helper.py line #907 1044 std::string vk_print_vkcommandbufferinheritanceinfo(const VkCommandBufferInheritanceInfo* pStruct, const std::string prefix) 1045 { 1046 // CODEGEN : file ../vk_helper.py line #913 1047 using namespace StreamControl; 1048 using namespace std; 1049 string final_str; 1050 string tmp_str; 1051 string extra_indent = " " + prefix; 1052 stringstream ss[7]; 1053 string stp_strs[1]; 1054 // CODEGEN : file ../vk_helper.py line #1012 1055 if (pStruct->pNext) { 1056 // CODEGEN : file ../vk_helper.py line #1016 1057 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1058 ss[0] << "0x" << &pStruct->pNext; 1059 // CODEGEN : file ../vk_helper.py line #1028 1060 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1061 ss[0].str(""); 1062 } 1063 else 1064 stp_strs[0] = ""; 1065 // CODEGEN : file ../vk_helper.py line #1070 1066 if (StreamControl::writeAddress) 1067 ss[0] << "0x" << pStruct->pNext; 1068 else 1069 ss[0].str("address"); 1070 // CODEGEN : file ../vk_helper.py line #1086 1071 ss[1] << "0x" << pStruct->renderPass; 1072 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1073 ss[2] << pStruct->subpass; 1074 // CODEGEN : file ../vk_helper.py line #1086 1075 ss[3] << "0x" << pStruct->framebuffer; 1076 // CODEGEN : file ../vk_helper.py line #1064 1077 ss[4].str(pStruct->occlusionQueryEnable ? "TRUE" : "FALSE"); 1078 // CODEGEN : file ../vk_helper.py line #1086 1079 ss[5] << "0x" << pStruct->queryFlags; 1080 // CODEGEN : file ../vk_helper.py line #1086 1081 ss[6] << "0x" << pStruct->pipelineStatistics; 1082 // CODEGEN : file ../vk_helper.py line #1113 1083 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1084 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1085 final_str = final_str + prefix + "renderPass = " + ss[1].str() + "\n"; 1086 final_str = final_str + prefix + "subpass = " + ss[2].str() + "\n"; 1087 final_str = final_str + prefix + "framebuffer = " + ss[3].str() + "\n"; 1088 final_str = final_str + prefix + "occlusionQueryEnable = " + ss[4].str() + "\n"; 1089 final_str = final_str + prefix + "queryFlags = " + ss[5].str() + "\n"; 1090 final_str = final_str + prefix + "pipelineStatistics = " + ss[6].str() + "\n"; 1091 final_str = final_str + stp_strs[0]; 1092 return final_str; 1093 } 1094 // CODEGEN : file ../vk_helper.py line #907 1095 std::string vk_print_vkcommandpoolcreateinfo(const VkCommandPoolCreateInfo* pStruct, const std::string prefix) 1096 { 1097 // CODEGEN : file ../vk_helper.py line #913 1098 using namespace StreamControl; 1099 using namespace std; 1100 string final_str; 1101 string tmp_str; 1102 string extra_indent = " " + prefix; 1103 stringstream ss[3]; 1104 string stp_strs[1]; 1105 // CODEGEN : file ../vk_helper.py line #1012 1106 if (pStruct->pNext) { 1107 // CODEGEN : file ../vk_helper.py line #1016 1108 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1109 ss[0] << "0x" << &pStruct->pNext; 1110 // CODEGEN : file ../vk_helper.py line #1028 1111 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1112 ss[0].str(""); 1113 } 1114 else 1115 stp_strs[0] = ""; 1116 // CODEGEN : file ../vk_helper.py line #1070 1117 if (StreamControl::writeAddress) 1118 ss[0] << "0x" << pStruct->pNext; 1119 else 1120 ss[0].str("address"); 1121 // CODEGEN : file ../vk_helper.py line #1086 1122 ss[1] << "0x" << pStruct->flags; 1123 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1124 ss[2] << pStruct->queueFamilyIndex; 1125 // CODEGEN : file ../vk_helper.py line #1113 1126 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1127 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1128 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 1129 final_str = final_str + prefix + "queueFamilyIndex = " + ss[2].str() + "\n"; 1130 final_str = final_str + stp_strs[0]; 1131 return final_str; 1132 } 1133 // CODEGEN : file ../vk_helper.py line #907 1134 std::string vk_print_vkcomponentmapping(const VkComponentMapping* pStruct, const std::string prefix) 1135 { 1136 // CODEGEN : file ../vk_helper.py line #913 1137 using namespace StreamControl; 1138 using namespace std; 1139 string final_str; 1140 string tmp_str; 1141 string extra_indent = " " + prefix; 1142 // CODEGEN : file ../vk_helper.py line #1113 1143 final_str = final_str + prefix + "r = " + string_VkComponentSwizzle(pStruct->r) + "\n"; 1144 final_str = final_str + prefix + "g = " + string_VkComponentSwizzle(pStruct->g) + "\n"; 1145 final_str = final_str + prefix + "b = " + string_VkComponentSwizzle(pStruct->b) + "\n"; 1146 final_str = final_str + prefix + "a = " + string_VkComponentSwizzle(pStruct->a) + "\n"; 1147 return final_str; 1148 } 1149 // CODEGEN : file ../vk_helper.py line #907 1150 std::string vk_print_vkcomputepipelinecreateinfo(const VkComputePipelineCreateInfo* pStruct, const std::string prefix) 1151 { 1152 // CODEGEN : file ../vk_helper.py line #913 1153 using namespace StreamControl; 1154 using namespace std; 1155 string final_str; 1156 string tmp_str; 1157 string extra_indent = " " + prefix; 1158 stringstream ss[6]; 1159 string stp_strs[2]; 1160 // CODEGEN : file ../vk_helper.py line #1012 1161 if (pStruct->pNext) { 1162 // CODEGEN : file ../vk_helper.py line #1016 1163 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1164 ss[0] << "0x" << &pStruct->pNext; 1165 // CODEGEN : file ../vk_helper.py line #1028 1166 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1167 ss[0].str(""); 1168 } 1169 else 1170 stp_strs[0] = ""; 1171 // CODEGEN : file ../vk_helper.py line #1038 1172 tmp_str = vk_print_vkpipelineshaderstagecreateinfo(&pStruct->stage, extra_indent); 1173 ss[1] << "0x" << &pStruct->stage; 1174 stp_strs[1] = " " + prefix + "stage (addr)\n" + tmp_str; 1175 // CODEGEN : file ../vk_helper.py line #1043 1176 ss[1].str(""); 1177 // CODEGEN : file ../vk_helper.py line #1070 1178 if (StreamControl::writeAddress) 1179 ss[0] << "0x" << pStruct->pNext; 1180 else 1181 ss[0].str("address"); 1182 // CODEGEN : file ../vk_helper.py line #1086 1183 ss[1] << "0x" << pStruct->flags; 1184 // CODEGEN : file ../vk_helper.py line #1055 1185 ss[2].str("addr"); 1186 // CODEGEN : file ../vk_helper.py line #1086 1187 ss[3] << "0x" << pStruct->layout; 1188 // CODEGEN : file ../vk_helper.py line #1086 1189 ss[4] << "0x" << pStruct->basePipelineHandle; 1190 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1191 ss[5] << pStruct->basePipelineIndex; 1192 // CODEGEN : file ../vk_helper.py line #1113 1193 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1194 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1195 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 1196 final_str = final_str + prefix + "stage = " + ss[2].str() + "\n"; 1197 final_str = final_str + prefix + "layout = " + ss[3].str() + "\n"; 1198 final_str = final_str + prefix + "basePipelineHandle = " + ss[4].str() + "\n"; 1199 final_str = final_str + prefix + "basePipelineIndex = " + ss[5].str() + "\n"; 1200 final_str = final_str + stp_strs[1] + stp_strs[0]; 1201 return final_str; 1202 } 1203 // CODEGEN : file ../vk_helper.py line #907 1204 std::string vk_print_vkcopydescriptorset(const VkCopyDescriptorSet* pStruct, const std::string prefix) 1205 { 1206 // CODEGEN : file ../vk_helper.py line #913 1207 using namespace StreamControl; 1208 using namespace std; 1209 string final_str; 1210 string tmp_str; 1211 string extra_indent = " " + prefix; 1212 stringstream ss[8]; 1213 string stp_strs[1]; 1214 // CODEGEN : file ../vk_helper.py line #1012 1215 if (pStruct->pNext) { 1216 // CODEGEN : file ../vk_helper.py line #1016 1217 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1218 ss[0] << "0x" << &pStruct->pNext; 1219 // CODEGEN : file ../vk_helper.py line #1028 1220 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1221 ss[0].str(""); 1222 } 1223 else 1224 stp_strs[0] = ""; 1225 // CODEGEN : file ../vk_helper.py line #1070 1226 if (StreamControl::writeAddress) 1227 ss[0] << "0x" << pStruct->pNext; 1228 else 1229 ss[0].str("address"); 1230 // CODEGEN : file ../vk_helper.py line #1086 1231 ss[1] << "0x" << pStruct->srcSet; 1232 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1233 ss[2] << pStruct->srcBinding; 1234 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1235 ss[3] << pStruct->srcArrayElement; 1236 // CODEGEN : file ../vk_helper.py line #1086 1237 ss[4] << "0x" << pStruct->dstSet; 1238 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1239 ss[5] << pStruct->dstBinding; 1240 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1241 ss[6] << pStruct->dstArrayElement; 1242 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1243 ss[7] << pStruct->descriptorCount; 1244 // CODEGEN : file ../vk_helper.py line #1113 1245 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1246 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1247 final_str = final_str + prefix + "srcSet = " + ss[1].str() + "\n"; 1248 final_str = final_str + prefix + "srcBinding = " + ss[2].str() + "\n"; 1249 final_str = final_str + prefix + "srcArrayElement = " + ss[3].str() + "\n"; 1250 final_str = final_str + prefix + "dstSet = " + ss[4].str() + "\n"; 1251 final_str = final_str + prefix + "dstBinding = " + ss[5].str() + "\n"; 1252 final_str = final_str + prefix + "dstArrayElement = " + ss[6].str() + "\n"; 1253 final_str = final_str + prefix + "descriptorCount = " + ss[7].str() + "\n"; 1254 final_str = final_str + stp_strs[0]; 1255 return final_str; 1256 } 1257 // CODEGEN : file ../vk_helper.py line #907 1258 std::string vk_print_vkdebugmarkermarkerinfoext(const VkDebugMarkerMarkerInfoEXT* pStruct, const std::string prefix) 1259 { 1260 // CODEGEN : file ../vk_helper.py line #913 1261 using namespace StreamControl; 1262 using namespace std; 1263 string final_str; 1264 string tmp_str; 1265 string extra_indent = " " + prefix; 1266 stringstream ss[3]; 1267 string stp_strs[2]; 1268 // CODEGEN : file ../vk_helper.py line #1012 1269 if (pStruct->pNext) { 1270 // CODEGEN : file ../vk_helper.py line #1016 1271 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1272 ss[0] << "0x" << &pStruct->pNext; 1273 // CODEGEN : file ../vk_helper.py line #1028 1274 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1275 ss[0].str(""); 1276 } 1277 else 1278 stp_strs[0] = ""; 1279 // CODEGEN : file ../vk_helper.py line #932 1280 // CODEGEN : file ../vk_helper.py line #937 1281 // CODEGEN : file ../vk_helper.py line #939 1282 stp_strs[1] = ""; 1283 stringstream index_ss; 1284 for (uint32_t i = 0; i < 4; i++) { 1285 index_ss.str(""); 1286 index_ss << i; 1287 // CODEGEN : file ../vk_helper.py line #990 1288 ss[1] << pStruct->color[i]; 1289 stp_strs[1] += " " + prefix + "color[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 1290 // CODEGEN : file ../vk_helper.py line #1000 1291 ss[1].str(""); 1292 } 1293 // CODEGEN : file ../vk_helper.py line #1070 1294 if (StreamControl::writeAddress) 1295 ss[0] << "0x" << pStruct->pNext; 1296 else 1297 ss[0].str("address"); 1298 // CODEGEN : file ../vk_helper.py line #1076 1299 if (pStruct->pMarkerName != NULL) { 1300 ss[1] << pStruct->pMarkerName; 1301 } else { 1302 ss[1] << ""; 1303 } 1304 // CODEGEN : file ../vk_helper.py line #1061 1305 ss[2] << "0x" << (void*)pStruct->color; 1306 // CODEGEN : file ../vk_helper.py line #1113 1307 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1308 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1309 final_str = final_str + prefix + "pMarkerName = " + ss[1].str() + "\n"; 1310 final_str = final_str + prefix + "color = " + ss[2].str() + "\n"; 1311 final_str = final_str + stp_strs[1] + stp_strs[0]; 1312 return final_str; 1313 } 1314 // CODEGEN : file ../vk_helper.py line #907 1315 std::string vk_print_vkdebugmarkerobjectnameinfoext(const VkDebugMarkerObjectNameInfoEXT* pStruct, const std::string prefix) 1316 { 1317 // CODEGEN : file ../vk_helper.py line #913 1318 using namespace StreamControl; 1319 using namespace std; 1320 string final_str; 1321 string tmp_str; 1322 string extra_indent = " " + prefix; 1323 stringstream ss[3]; 1324 string stp_strs[1]; 1325 // CODEGEN : file ../vk_helper.py line #1012 1326 if (pStruct->pNext) { 1327 // CODEGEN : file ../vk_helper.py line #1016 1328 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1329 ss[0] << "0x" << &pStruct->pNext; 1330 // CODEGEN : file ../vk_helper.py line #1028 1331 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1332 ss[0].str(""); 1333 } 1334 else 1335 stp_strs[0] = ""; 1336 // CODEGEN : file ../vk_helper.py line #1070 1337 if (StreamControl::writeAddress) 1338 ss[0] << "0x" << pStruct->pNext; 1339 else 1340 ss[0].str("address"); 1341 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 1342 ss[1] << "0x" << pStruct->object; 1343 // CODEGEN : file ../vk_helper.py line #1076 1344 if (pStruct->pObjectName != NULL) { 1345 ss[2] << pStruct->pObjectName; 1346 } else { 1347 ss[2] << ""; 1348 } 1349 // CODEGEN : file ../vk_helper.py line #1113 1350 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1351 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1352 final_str = final_str + prefix + "objectType = " + string_VkDebugReportObjectTypeEXT(pStruct->objectType) + "\n"; 1353 final_str = final_str + prefix + "object = " + ss[1].str() + "\n"; 1354 final_str = final_str + prefix + "pObjectName = " + ss[2].str() + "\n"; 1355 final_str = final_str + stp_strs[0]; 1356 return final_str; 1357 } 1358 // CODEGEN : file ../vk_helper.py line #907 1359 std::string vk_print_vkdebugmarkerobjecttaginfoext(const VkDebugMarkerObjectTagInfoEXT* pStruct, const std::string prefix) 1360 { 1361 // CODEGEN : file ../vk_helper.py line #913 1362 using namespace StreamControl; 1363 using namespace std; 1364 string final_str; 1365 string tmp_str; 1366 string extra_indent = " " + prefix; 1367 stringstream ss[5]; 1368 string stp_strs[1]; 1369 // CODEGEN : file ../vk_helper.py line #1012 1370 if (pStruct->pNext) { 1371 // CODEGEN : file ../vk_helper.py line #1016 1372 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1373 ss[0] << "0x" << &pStruct->pNext; 1374 // CODEGEN : file ../vk_helper.py line #1028 1375 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1376 ss[0].str(""); 1377 } 1378 else 1379 stp_strs[0] = ""; 1380 // CODEGEN : file ../vk_helper.py line #1070 1381 if (StreamControl::writeAddress) 1382 ss[0] << "0x" << pStruct->pNext; 1383 else 1384 ss[0].str("address"); 1385 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 1386 ss[1] << "0x" << pStruct->object; 1387 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1388 ss[2] << pStruct->tagName; 1389 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1390 ss[3] << pStruct->tagSize; 1391 // CODEGEN : file ../vk_helper.py line #1070 1392 if (StreamControl::writeAddress) 1393 ss[4] << "0x" << pStruct->pTag; 1394 else 1395 ss[4].str("address"); 1396 // CODEGEN : file ../vk_helper.py line #1113 1397 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1398 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1399 final_str = final_str + prefix + "objectType = " + string_VkDebugReportObjectTypeEXT(pStruct->objectType) + "\n"; 1400 final_str = final_str + prefix + "object = " + ss[1].str() + "\n"; 1401 final_str = final_str + prefix + "tagName = " + ss[2].str() + "\n"; 1402 final_str = final_str + prefix + "tagSize = " + ss[3].str() + "\n"; 1403 final_str = final_str + prefix + "pTag = " + ss[4].str() + "\n"; 1404 final_str = final_str + stp_strs[0]; 1405 return final_str; 1406 } 1407 // CODEGEN : file ../vk_helper.py line #907 1408 std::string vk_print_vkdebugreportcallbackcreateinfoext(const VkDebugReportCallbackCreateInfoEXT* pStruct, const std::string prefix) 1409 { 1410 // CODEGEN : file ../vk_helper.py line #913 1411 using namespace StreamControl; 1412 using namespace std; 1413 string final_str; 1414 string tmp_str; 1415 string extra_indent = " " + prefix; 1416 stringstream ss[4]; 1417 string stp_strs[1]; 1418 // CODEGEN : file ../vk_helper.py line #1012 1419 if (pStruct->pNext) { 1420 // CODEGEN : file ../vk_helper.py line #1016 1421 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1422 ss[0] << "0x" << &pStruct->pNext; 1423 // CODEGEN : file ../vk_helper.py line #1028 1424 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1425 ss[0].str(""); 1426 } 1427 else 1428 stp_strs[0] = ""; 1429 // CODEGEN : file ../vk_helper.py line #1070 1430 if (StreamControl::writeAddress) 1431 ss[0] << "0x" << pStruct->pNext; 1432 else 1433 ss[0].str("address"); 1434 // CODEGEN : file ../vk_helper.py line #1086 1435 ss[1] << "0x" << pStruct->flags; 1436 // CODEGEN : file ../vk_helper.py line #1086 1437 ss[2] << "0x" << pStruct->pfnCallback; 1438 // CODEGEN : file ../vk_helper.py line #1070 1439 if (StreamControl::writeAddress) 1440 ss[3] << "0x" << pStruct->pUserData; 1441 else 1442 ss[3].str("address"); 1443 // CODEGEN : file ../vk_helper.py line #1113 1444 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1445 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1446 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 1447 final_str = final_str + prefix + "pfnCallback = " + ss[2].str() + "\n"; 1448 final_str = final_str + prefix + "pUserData = " + ss[3].str() + "\n"; 1449 final_str = final_str + stp_strs[0]; 1450 return final_str; 1451 } 1452 // CODEGEN : file ../vk_helper.py line #907 1453 std::string vk_print_vkdedicatedallocationbuffercreateinfonv(const VkDedicatedAllocationBufferCreateInfoNV* pStruct, const std::string prefix) 1454 { 1455 // CODEGEN : file ../vk_helper.py line #913 1456 using namespace StreamControl; 1457 using namespace std; 1458 string final_str; 1459 string tmp_str; 1460 string extra_indent = " " + prefix; 1461 stringstream ss[2]; 1462 string stp_strs[1]; 1463 // CODEGEN : file ../vk_helper.py line #1012 1464 if (pStruct->pNext) { 1465 // CODEGEN : file ../vk_helper.py line #1016 1466 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1467 ss[0] << "0x" << &pStruct->pNext; 1468 // CODEGEN : file ../vk_helper.py line #1028 1469 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1470 ss[0].str(""); 1471 } 1472 else 1473 stp_strs[0] = ""; 1474 // CODEGEN : file ../vk_helper.py line #1070 1475 if (StreamControl::writeAddress) 1476 ss[0] << "0x" << pStruct->pNext; 1477 else 1478 ss[0].str("address"); 1479 // CODEGEN : file ../vk_helper.py line #1064 1480 ss[1].str(pStruct->dedicatedAllocation ? "TRUE" : "FALSE"); 1481 // CODEGEN : file ../vk_helper.py line #1113 1482 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1483 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1484 final_str = final_str + prefix + "dedicatedAllocation = " + ss[1].str() + "\n"; 1485 final_str = final_str + stp_strs[0]; 1486 return final_str; 1487 } 1488 // CODEGEN : file ../vk_helper.py line #907 1489 std::string vk_print_vkdedicatedallocationimagecreateinfonv(const VkDedicatedAllocationImageCreateInfoNV* pStruct, const std::string prefix) 1490 { 1491 // CODEGEN : file ../vk_helper.py line #913 1492 using namespace StreamControl; 1493 using namespace std; 1494 string final_str; 1495 string tmp_str; 1496 string extra_indent = " " + prefix; 1497 stringstream ss[2]; 1498 string stp_strs[1]; 1499 // CODEGEN : file ../vk_helper.py line #1012 1500 if (pStruct->pNext) { 1501 // CODEGEN : file ../vk_helper.py line #1016 1502 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1503 ss[0] << "0x" << &pStruct->pNext; 1504 // CODEGEN : file ../vk_helper.py line #1028 1505 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1506 ss[0].str(""); 1507 } 1508 else 1509 stp_strs[0] = ""; 1510 // CODEGEN : file ../vk_helper.py line #1070 1511 if (StreamControl::writeAddress) 1512 ss[0] << "0x" << pStruct->pNext; 1513 else 1514 ss[0].str("address"); 1515 // CODEGEN : file ../vk_helper.py line #1064 1516 ss[1].str(pStruct->dedicatedAllocation ? "TRUE" : "FALSE"); 1517 // CODEGEN : file ../vk_helper.py line #1113 1518 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1519 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1520 final_str = final_str + prefix + "dedicatedAllocation = " + ss[1].str() + "\n"; 1521 final_str = final_str + stp_strs[0]; 1522 return final_str; 1523 } 1524 // CODEGEN : file ../vk_helper.py line #907 1525 std::string vk_print_vkdedicatedallocationmemoryallocateinfonv(const VkDedicatedAllocationMemoryAllocateInfoNV* pStruct, const std::string prefix) 1526 { 1527 // CODEGEN : file ../vk_helper.py line #913 1528 using namespace StreamControl; 1529 using namespace std; 1530 string final_str; 1531 string tmp_str; 1532 string extra_indent = " " + prefix; 1533 stringstream ss[3]; 1534 string stp_strs[1]; 1535 // CODEGEN : file ../vk_helper.py line #1012 1536 if (pStruct->pNext) { 1537 // CODEGEN : file ../vk_helper.py line #1016 1538 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1539 ss[0] << "0x" << &pStruct->pNext; 1540 // CODEGEN : file ../vk_helper.py line #1028 1541 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1542 ss[0].str(""); 1543 } 1544 else 1545 stp_strs[0] = ""; 1546 // CODEGEN : file ../vk_helper.py line #1070 1547 if (StreamControl::writeAddress) 1548 ss[0] << "0x" << pStruct->pNext; 1549 else 1550 ss[0].str("address"); 1551 // CODEGEN : file ../vk_helper.py line #1086 1552 ss[1] << "0x" << pStruct->image; 1553 // CODEGEN : file ../vk_helper.py line #1086 1554 ss[2] << "0x" << pStruct->buffer; 1555 // CODEGEN : file ../vk_helper.py line #1113 1556 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1557 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1558 final_str = final_str + prefix + "image = " + ss[1].str() + "\n"; 1559 final_str = final_str + prefix + "buffer = " + ss[2].str() + "\n"; 1560 final_str = final_str + stp_strs[0]; 1561 return final_str; 1562 } 1563 // CODEGEN : file ../vk_helper.py line #907 1564 std::string vk_print_vkdescriptorbufferinfo(const VkDescriptorBufferInfo* pStruct, const std::string prefix) 1565 { 1566 // CODEGEN : file ../vk_helper.py line #913 1567 using namespace StreamControl; 1568 using namespace std; 1569 string final_str; 1570 string tmp_str; 1571 string extra_indent = " " + prefix; 1572 stringstream ss[3]; 1573 // CODEGEN : file ../vk_helper.py line #1086 1574 ss[0] << "0x" << pStruct->buffer; 1575 // CODEGEN : file ../vk_helper.py line #1086 1576 ss[1] << "0x" << pStruct->offset; 1577 // CODEGEN : file ../vk_helper.py line #1086 1578 ss[2] << "0x" << pStruct->range; 1579 // CODEGEN : file ../vk_helper.py line #1113 1580 final_str = final_str + prefix + "buffer = " + ss[0].str() + "\n"; 1581 final_str = final_str + prefix + "offset = " + ss[1].str() + "\n"; 1582 final_str = final_str + prefix + "range = " + ss[2].str() + "\n"; 1583 return final_str; 1584 } 1585 // CODEGEN : file ../vk_helper.py line #907 1586 std::string vk_print_vkdescriptorimageinfo(const VkDescriptorImageInfo* pStruct, const std::string prefix) 1587 { 1588 // CODEGEN : file ../vk_helper.py line #913 1589 using namespace StreamControl; 1590 using namespace std; 1591 string final_str; 1592 string tmp_str; 1593 string extra_indent = " " + prefix; 1594 stringstream ss[2]; 1595 // CODEGEN : file ../vk_helper.py line #1086 1596 ss[0] << "0x" << pStruct->sampler; 1597 // CODEGEN : file ../vk_helper.py line #1086 1598 ss[1] << "0x" << pStruct->imageView; 1599 // CODEGEN : file ../vk_helper.py line #1113 1600 final_str = final_str + prefix + "sampler = " + ss[0].str() + "\n"; 1601 final_str = final_str + prefix + "imageView = " + ss[1].str() + "\n"; 1602 final_str = final_str + prefix + "imageLayout = " + string_VkImageLayout(pStruct->imageLayout) + "\n"; 1603 return final_str; 1604 } 1605 // CODEGEN : file ../vk_helper.py line #907 1606 std::string vk_print_vkdescriptorpoolcreateinfo(const VkDescriptorPoolCreateInfo* pStruct, const std::string prefix) 1607 { 1608 // CODEGEN : file ../vk_helper.py line #913 1609 using namespace StreamControl; 1610 using namespace std; 1611 string final_str; 1612 string tmp_str; 1613 string extra_indent = " " + prefix; 1614 stringstream ss[5]; 1615 string stp_strs[2]; 1616 // CODEGEN : file ../vk_helper.py line #1012 1617 if (pStruct->pNext) { 1618 // CODEGEN : file ../vk_helper.py line #1016 1619 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1620 ss[0] << "0x" << &pStruct->pNext; 1621 // CODEGEN : file ../vk_helper.py line #1028 1622 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1623 ss[0].str(""); 1624 } 1625 else 1626 stp_strs[0] = ""; 1627 // CODEGEN : file ../vk_helper.py line #932 1628 // CODEGEN : file ../vk_helper.py line #934 1629 // CODEGEN : file ../vk_helper.py line #939 1630 stp_strs[1] = ""; 1631 stringstream index_ss; 1632 if (pStruct->pPoolSizes) { 1633 for (uint32_t i = 0; i < pStruct->poolSizeCount; i++) { 1634 index_ss.str(""); 1635 index_ss << i; 1636 // CODEGEN : file ../vk_helper.py line #980 1637 ss[1] << "0x" << &pStruct->pPoolSizes[i]; 1638 tmp_str = vk_print_vkdescriptorpoolsize(&pStruct->pPoolSizes[i], extra_indent); 1639 // CODEGEN : file ../vk_helper.py line #984 1640 stp_strs[1] += " " + prefix + "pPoolSizes[" + index_ss.str() + "] (addr)\n" + tmp_str; 1641 // CODEGEN : file ../vk_helper.py line #1000 1642 ss[1].str(""); 1643 } 1644 } 1645 // CODEGEN : file ../vk_helper.py line #1070 1646 if (StreamControl::writeAddress) 1647 ss[0] << "0x" << pStruct->pNext; 1648 else 1649 ss[0].str("address"); 1650 // CODEGEN : file ../vk_helper.py line #1086 1651 ss[1] << "0x" << pStruct->flags; 1652 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1653 ss[2] << pStruct->maxSets; 1654 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1655 ss[3] << pStruct->poolSizeCount; 1656 // CODEGEN : file ../vk_helper.py line #1061 1657 ss[4] << "0x" << (void*)pStruct->pPoolSizes; 1658 // CODEGEN : file ../vk_helper.py line #1113 1659 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1660 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1661 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 1662 final_str = final_str + prefix + "maxSets = " + ss[2].str() + "\n"; 1663 final_str = final_str + prefix + "poolSizeCount = " + ss[3].str() + "\n"; 1664 final_str = final_str + prefix + "pPoolSizes = " + ss[4].str() + "\n"; 1665 final_str = final_str + stp_strs[1] + stp_strs[0]; 1666 return final_str; 1667 } 1668 // CODEGEN : file ../vk_helper.py line #907 1669 std::string vk_print_vkdescriptorpoolsize(const VkDescriptorPoolSize* pStruct, const std::string prefix) 1670 { 1671 // CODEGEN : file ../vk_helper.py line #913 1672 using namespace StreamControl; 1673 using namespace std; 1674 string final_str; 1675 string tmp_str; 1676 string extra_indent = " " + prefix; 1677 stringstream ss[1]; 1678 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1679 ss[0] << pStruct->descriptorCount; 1680 // CODEGEN : file ../vk_helper.py line #1113 1681 final_str = final_str + prefix + "type = " + string_VkDescriptorType(pStruct->type) + "\n"; 1682 final_str = final_str + prefix + "descriptorCount = " + ss[0].str() + "\n"; 1683 return final_str; 1684 } 1685 // CODEGEN : file ../vk_helper.py line #907 1686 std::string vk_print_vkdescriptorsetallocateinfo(const VkDescriptorSetAllocateInfo* pStruct, const std::string prefix) 1687 { 1688 // CODEGEN : file ../vk_helper.py line #913 1689 using namespace StreamControl; 1690 using namespace std; 1691 string final_str; 1692 string tmp_str; 1693 string extra_indent = " " + prefix; 1694 stringstream ss[4]; 1695 string stp_strs[2]; 1696 // CODEGEN : file ../vk_helper.py line #1012 1697 if (pStruct->pNext) { 1698 // CODEGEN : file ../vk_helper.py line #1016 1699 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1700 ss[0] << "0x" << &pStruct->pNext; 1701 // CODEGEN : file ../vk_helper.py line #1028 1702 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1703 ss[0].str(""); 1704 } 1705 else 1706 stp_strs[0] = ""; 1707 // CODEGEN : file ../vk_helper.py line #932 1708 // CODEGEN : file ../vk_helper.py line #934 1709 // CODEGEN : file ../vk_helper.py line #939 1710 stp_strs[1] = ""; 1711 stringstream index_ss; 1712 if (pStruct->pSetLayouts) { 1713 for (uint32_t i = 0; i < pStruct->descriptorSetCount; i++) { 1714 index_ss.str(""); 1715 index_ss << i; 1716 // CODEGEN : file ../vk_helper.py line #990 1717 ss[1] << "0x" << pStruct->pSetLayouts[i]; 1718 stp_strs[1] += " " + prefix + "pSetLayouts[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 1719 // CODEGEN : file ../vk_helper.py line #1000 1720 ss[1].str(""); 1721 } 1722 } 1723 // CODEGEN : file ../vk_helper.py line #1070 1724 if (StreamControl::writeAddress) 1725 ss[0] << "0x" << pStruct->pNext; 1726 else 1727 ss[0].str("address"); 1728 // CODEGEN : file ../vk_helper.py line #1086 1729 ss[1] << "0x" << pStruct->descriptorPool; 1730 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1731 ss[2] << pStruct->descriptorSetCount; 1732 // CODEGEN : file ../vk_helper.py line #1061 1733 ss[3] << "0x" << (void*)pStruct->pSetLayouts; 1734 // CODEGEN : file ../vk_helper.py line #1113 1735 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1736 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1737 final_str = final_str + prefix + "descriptorPool = " + ss[1].str() + "\n"; 1738 final_str = final_str + prefix + "descriptorSetCount = " + ss[2].str() + "\n"; 1739 final_str = final_str + prefix + "pSetLayouts = " + ss[3].str() + "\n"; 1740 final_str = final_str + stp_strs[1] + stp_strs[0]; 1741 return final_str; 1742 } 1743 // CODEGEN : file ../vk_helper.py line #907 1744 std::string vk_print_vkdescriptorsetlayoutbinding(const VkDescriptorSetLayoutBinding* pStruct, const std::string prefix) 1745 { 1746 // CODEGEN : file ../vk_helper.py line #913 1747 using namespace StreamControl; 1748 using namespace std; 1749 string final_str; 1750 string tmp_str; 1751 string extra_indent = " " + prefix; 1752 stringstream ss[4]; 1753 string stp_strs[1]; 1754 // CODEGEN : file ../vk_helper.py line #932 1755 // CODEGEN : file ../vk_helper.py line #934 1756 // CODEGEN : file ../vk_helper.py line #939 1757 stp_strs[0] = ""; 1758 stringstream index_ss; 1759 if (pStruct->pImmutableSamplers) { 1760 for (uint32_t i = 0; i < pStruct->descriptorCount; i++) { 1761 index_ss.str(""); 1762 index_ss << i; 1763 // CODEGEN : file ../vk_helper.py line #990 1764 ss[0] << "0x" << pStruct->pImmutableSamplers[i]; 1765 stp_strs[0] += " " + prefix + "pImmutableSamplers[" + index_ss.str() + "].handle = " + ss[0].str() + "\n"; 1766 // CODEGEN : file ../vk_helper.py line #1000 1767 ss[0].str(""); 1768 } 1769 } 1770 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1771 ss[0] << pStruct->binding; 1772 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1773 ss[1] << pStruct->descriptorCount; 1774 // CODEGEN : file ../vk_helper.py line #1086 1775 ss[2] << "0x" << pStruct->stageFlags; 1776 // CODEGEN : file ../vk_helper.py line #1061 1777 ss[3] << "0x" << (void*)pStruct->pImmutableSamplers; 1778 // CODEGEN : file ../vk_helper.py line #1113 1779 final_str = final_str + prefix + "binding = " + ss[0].str() + "\n"; 1780 final_str = final_str + prefix + "descriptorType = " + string_VkDescriptorType(pStruct->descriptorType) + "\n"; 1781 final_str = final_str + prefix + "descriptorCount = " + ss[1].str() + "\n"; 1782 final_str = final_str + prefix + "stageFlags = " + ss[2].str() + "\n"; 1783 final_str = final_str + prefix + "pImmutableSamplers = " + ss[3].str() + "\n"; 1784 final_str = final_str + stp_strs[0]; 1785 return final_str; 1786 } 1787 // CODEGEN : file ../vk_helper.py line #907 1788 std::string vk_print_vkdescriptorsetlayoutcreateinfo(const VkDescriptorSetLayoutCreateInfo* pStruct, const std::string prefix) 1789 { 1790 // CODEGEN : file ../vk_helper.py line #913 1791 using namespace StreamControl; 1792 using namespace std; 1793 string final_str; 1794 string tmp_str; 1795 string extra_indent = " " + prefix; 1796 stringstream ss[4]; 1797 string stp_strs[2]; 1798 // CODEGEN : file ../vk_helper.py line #1012 1799 if (pStruct->pNext) { 1800 // CODEGEN : file ../vk_helper.py line #1016 1801 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1802 ss[0] << "0x" << &pStruct->pNext; 1803 // CODEGEN : file ../vk_helper.py line #1028 1804 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1805 ss[0].str(""); 1806 } 1807 else 1808 stp_strs[0] = ""; 1809 // CODEGEN : file ../vk_helper.py line #932 1810 // CODEGEN : file ../vk_helper.py line #934 1811 // CODEGEN : file ../vk_helper.py line #939 1812 stp_strs[1] = ""; 1813 stringstream index_ss; 1814 if (pStruct->pBindings) { 1815 for (uint32_t i = 0; i < pStruct->bindingCount; i++) { 1816 index_ss.str(""); 1817 index_ss << i; 1818 // CODEGEN : file ../vk_helper.py line #980 1819 ss[1] << "0x" << &pStruct->pBindings[i]; 1820 tmp_str = vk_print_vkdescriptorsetlayoutbinding(&pStruct->pBindings[i], extra_indent); 1821 // CODEGEN : file ../vk_helper.py line #984 1822 stp_strs[1] += " " + prefix + "pBindings[" + index_ss.str() + "] (addr)\n" + tmp_str; 1823 // CODEGEN : file ../vk_helper.py line #1000 1824 ss[1].str(""); 1825 } 1826 } 1827 // CODEGEN : file ../vk_helper.py line #1070 1828 if (StreamControl::writeAddress) 1829 ss[0] << "0x" << pStruct->pNext; 1830 else 1831 ss[0].str("address"); 1832 // CODEGEN : file ../vk_helper.py line #1086 1833 ss[1] << "0x" << pStruct->flags; 1834 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1835 ss[2] << pStruct->bindingCount; 1836 // CODEGEN : file ../vk_helper.py line #1061 1837 ss[3] << "0x" << (void*)pStruct->pBindings; 1838 // CODEGEN : file ../vk_helper.py line #1113 1839 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1840 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1841 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 1842 final_str = final_str + prefix + "bindingCount = " + ss[2].str() + "\n"; 1843 final_str = final_str + prefix + "pBindings = " + ss[3].str() + "\n"; 1844 final_str = final_str + stp_strs[1] + stp_strs[0]; 1845 return final_str; 1846 } 1847 // CODEGEN : file ../vk_helper.py line #907 1848 std::string vk_print_vkdevicecreateinfo(const VkDeviceCreateInfo* pStruct, const std::string prefix) 1849 { 1850 // CODEGEN : file ../vk_helper.py line #913 1851 using namespace StreamControl; 1852 using namespace std; 1853 string final_str; 1854 string tmp_str; 1855 string extra_indent = " " + prefix; 1856 stringstream ss[9]; 1857 string stp_strs[5]; 1858 // CODEGEN : file ../vk_helper.py line #1012 1859 if (pStruct->pNext) { 1860 // CODEGEN : file ../vk_helper.py line #1016 1861 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1862 ss[0] << "0x" << &pStruct->pNext; 1863 // CODEGEN : file ../vk_helper.py line #1028 1864 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1865 ss[0].str(""); 1866 } 1867 else 1868 stp_strs[0] = ""; 1869 // CODEGEN : file ../vk_helper.py line #932 1870 // CODEGEN : file ../vk_helper.py line #934 1871 // CODEGEN : file ../vk_helper.py line #939 1872 stp_strs[1] = ""; 1873 stringstream index_ss; 1874 if (pStruct->pQueueCreateInfos) { 1875 for (uint32_t i = 0; i < pStruct->queueCreateInfoCount; i++) { 1876 index_ss.str(""); 1877 index_ss << i; 1878 // CODEGEN : file ../vk_helper.py line #980 1879 ss[1] << "0x" << &pStruct->pQueueCreateInfos[i]; 1880 tmp_str = vk_print_vkdevicequeuecreateinfo(&pStruct->pQueueCreateInfos[i], extra_indent); 1881 // CODEGEN : file ../vk_helper.py line #984 1882 stp_strs[1] += " " + prefix + "pQueueCreateInfos[" + index_ss.str() + "] (addr)\n" + tmp_str; 1883 // CODEGEN : file ../vk_helper.py line #1000 1884 ss[1].str(""); 1885 } 1886 } 1887 // CODEGEN : file ../vk_helper.py line #932 1888 // CODEGEN : file ../vk_helper.py line #934 1889 // CODEGEN : file ../vk_helper.py line #939 1890 stp_strs[2] = ""; 1891 if (pStruct->ppEnabledLayerNames) { 1892 for (uint32_t i = 0; i < pStruct->enabledLayerCount; i++) { 1893 index_ss.str(""); 1894 index_ss << i; 1895 // CODEGEN : file ../vk_helper.py line #990 1896 ss[2] << "0x" << pStruct->ppEnabledLayerNames[i]; 1897 stp_strs[2] += " " + prefix + "ppEnabledLayerNames[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 1898 // CODEGEN : file ../vk_helper.py line #1000 1899 ss[2].str(""); 1900 } 1901 } 1902 // CODEGEN : file ../vk_helper.py line #932 1903 // CODEGEN : file ../vk_helper.py line #934 1904 // CODEGEN : file ../vk_helper.py line #939 1905 stp_strs[3] = ""; 1906 if (pStruct->ppEnabledExtensionNames) { 1907 for (uint32_t i = 0; i < pStruct->enabledExtensionCount; i++) { 1908 index_ss.str(""); 1909 index_ss << i; 1910 // CODEGEN : file ../vk_helper.py line #990 1911 ss[3] << "0x" << pStruct->ppEnabledExtensionNames[i]; 1912 stp_strs[3] += " " + prefix + "ppEnabledExtensionNames[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 1913 // CODEGEN : file ../vk_helper.py line #1000 1914 ss[3].str(""); 1915 } 1916 } 1917 // CODEGEN : file ../vk_helper.py line #1012 1918 if (pStruct->pEnabledFeatures) { 1919 // CODEGEN : file ../vk_helper.py line #1024 1920 tmp_str = vk_print_vkphysicaldevicefeatures(pStruct->pEnabledFeatures, extra_indent); 1921 ss[4] << "0x" << &pStruct->pEnabledFeatures; 1922 // CODEGEN : file ../vk_helper.py line #1028 1923 stp_strs[4] = " " + prefix + "pEnabledFeatures (addr)\n" + tmp_str; 1924 ss[4].str(""); 1925 } 1926 else 1927 stp_strs[4] = ""; 1928 // CODEGEN : file ../vk_helper.py line #1070 1929 if (StreamControl::writeAddress) 1930 ss[0] << "0x" << pStruct->pNext; 1931 else 1932 ss[0].str("address"); 1933 // CODEGEN : file ../vk_helper.py line #1086 1934 ss[1] << "0x" << pStruct->flags; 1935 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1936 ss[2] << pStruct->queueCreateInfoCount; 1937 // CODEGEN : file ../vk_helper.py line #1061 1938 ss[3] << "0x" << (void*)pStruct->pQueueCreateInfos; 1939 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1940 ss[4] << pStruct->enabledLayerCount; 1941 // CODEGEN : file ../vk_helper.py line #1061 1942 ss[5] << "0x" << (void*)pStruct->ppEnabledLayerNames; 1943 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 1944 ss[6] << pStruct->enabledExtensionCount; 1945 // CODEGEN : file ../vk_helper.py line #1061 1946 ss[7] << "0x" << (void*)pStruct->ppEnabledExtensionNames; 1947 // CODEGEN : file ../vk_helper.py line #1086 1948 ss[8] << "0x" << pStruct->pEnabledFeatures; 1949 // CODEGEN : file ../vk_helper.py line #1113 1950 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 1951 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 1952 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 1953 final_str = final_str + prefix + "queueCreateInfoCount = " + ss[2].str() + "\n"; 1954 final_str = final_str + prefix + "pQueueCreateInfos = " + ss[3].str() + "\n"; 1955 final_str = final_str + prefix + "enabledLayerCount = " + ss[4].str() + "\n"; 1956 final_str = final_str + prefix + "ppEnabledLayerNames = " + ss[5].str() + "\n"; 1957 final_str = final_str + prefix + "enabledExtensionCount = " + ss[6].str() + "\n"; 1958 final_str = final_str + prefix + "ppEnabledExtensionNames = " + ss[7].str() + "\n"; 1959 final_str = final_str + prefix + "pEnabledFeatures = " + ss[8].str() + "\n"; 1960 final_str = final_str + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 1961 return final_str; 1962 } 1963 // CODEGEN : file ../vk_helper.py line #907 1964 std::string vk_print_vkdevicequeuecreateinfo(const VkDeviceQueueCreateInfo* pStruct, const std::string prefix) 1965 { 1966 // CODEGEN : file ../vk_helper.py line #913 1967 using namespace StreamControl; 1968 using namespace std; 1969 string final_str; 1970 string tmp_str; 1971 string extra_indent = " " + prefix; 1972 stringstream ss[5]; 1973 string stp_strs[2]; 1974 // CODEGEN : file ../vk_helper.py line #1012 1975 if (pStruct->pNext) { 1976 // CODEGEN : file ../vk_helper.py line #1016 1977 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 1978 ss[0] << "0x" << &pStruct->pNext; 1979 // CODEGEN : file ../vk_helper.py line #1028 1980 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 1981 ss[0].str(""); 1982 } 1983 else 1984 stp_strs[0] = ""; 1985 // CODEGEN : file ../vk_helper.py line #932 1986 // CODEGEN : file ../vk_helper.py line #934 1987 // CODEGEN : file ../vk_helper.py line #939 1988 stp_strs[1] = ""; 1989 stringstream index_ss; 1990 if (pStruct->pQueuePriorities) { 1991 for (uint32_t i = 0; i < pStruct->queueCount; i++) { 1992 index_ss.str(""); 1993 index_ss << i; 1994 // CODEGEN : file ../vk_helper.py line #990 1995 ss[1] << "0x" << pStruct->pQueuePriorities[i]; 1996 stp_strs[1] += " " + prefix + "pQueuePriorities[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 1997 // CODEGEN : file ../vk_helper.py line #1000 1998 ss[1].str(""); 1999 } 2000 } 2001 // CODEGEN : file ../vk_helper.py line #1070 2002 if (StreamControl::writeAddress) 2003 ss[0] << "0x" << pStruct->pNext; 2004 else 2005 ss[0].str("address"); 2006 // CODEGEN : file ../vk_helper.py line #1086 2007 ss[1] << "0x" << pStruct->flags; 2008 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2009 ss[2] << pStruct->queueFamilyIndex; 2010 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2011 ss[3] << pStruct->queueCount; 2012 // CODEGEN : file ../vk_helper.py line #1061 2013 ss[4] << "0x" << (void*)pStruct->pQueuePriorities; 2014 // CODEGEN : file ../vk_helper.py line #1113 2015 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2016 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2017 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 2018 final_str = final_str + prefix + "queueFamilyIndex = " + ss[2].str() + "\n"; 2019 final_str = final_str + prefix + "queueCount = " + ss[3].str() + "\n"; 2020 final_str = final_str + prefix + "pQueuePriorities = " + ss[4].str() + "\n"; 2021 final_str = final_str + stp_strs[1] + stp_strs[0]; 2022 return final_str; 2023 } 2024 // CODEGEN : file ../vk_helper.py line #907 2025 std::string vk_print_vkdispatchindirectcommand(const VkDispatchIndirectCommand* pStruct, const std::string prefix) 2026 { 2027 // CODEGEN : file ../vk_helper.py line #913 2028 using namespace StreamControl; 2029 using namespace std; 2030 string final_str; 2031 string tmp_str; 2032 string extra_indent = " " + prefix; 2033 stringstream ss[3]; 2034 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2035 ss[0] << pStruct->x; 2036 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2037 ss[1] << pStruct->y; 2038 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2039 ss[2] << pStruct->z; 2040 // CODEGEN : file ../vk_helper.py line #1113 2041 final_str = final_str + prefix + "x = " + ss[0].str() + "\n"; 2042 final_str = final_str + prefix + "y = " + ss[1].str() + "\n"; 2043 final_str = final_str + prefix + "z = " + ss[2].str() + "\n"; 2044 return final_str; 2045 } 2046 // CODEGEN : file ../vk_helper.py line #907 2047 std::string vk_print_vkdisplaymodecreateinfokhr(const VkDisplayModeCreateInfoKHR* pStruct, const std::string prefix) 2048 { 2049 // CODEGEN : file ../vk_helper.py line #913 2050 using namespace StreamControl; 2051 using namespace std; 2052 string final_str; 2053 string tmp_str; 2054 string extra_indent = " " + prefix; 2055 stringstream ss[3]; 2056 string stp_strs[2]; 2057 // CODEGEN : file ../vk_helper.py line #1012 2058 if (pStruct->pNext) { 2059 // CODEGEN : file ../vk_helper.py line #1016 2060 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2061 ss[0] << "0x" << &pStruct->pNext; 2062 // CODEGEN : file ../vk_helper.py line #1028 2063 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2064 ss[0].str(""); 2065 } 2066 else 2067 stp_strs[0] = ""; 2068 // CODEGEN : file ../vk_helper.py line #1038 2069 tmp_str = vk_print_vkdisplaymodeparameterskhr(&pStruct->parameters, extra_indent); 2070 ss[1] << "0x" << &pStruct->parameters; 2071 stp_strs[1] = " " + prefix + "parameters (addr)\n" + tmp_str; 2072 // CODEGEN : file ../vk_helper.py line #1043 2073 ss[1].str(""); 2074 // CODEGEN : file ../vk_helper.py line #1070 2075 if (StreamControl::writeAddress) 2076 ss[0] << "0x" << pStruct->pNext; 2077 else 2078 ss[0].str("address"); 2079 // CODEGEN : file ../vk_helper.py line #1086 2080 ss[1] << "0x" << pStruct->flags; 2081 // CODEGEN : file ../vk_helper.py line #1055 2082 ss[2].str("addr"); 2083 // CODEGEN : file ../vk_helper.py line #1113 2084 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2085 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2086 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 2087 final_str = final_str + prefix + "parameters = " + ss[2].str() + "\n"; 2088 final_str = final_str + stp_strs[1] + stp_strs[0]; 2089 return final_str; 2090 } 2091 // CODEGEN : file ../vk_helper.py line #907 2092 std::string vk_print_vkdisplaymodeparameterskhr(const VkDisplayModeParametersKHR* pStruct, const std::string prefix) 2093 { 2094 // CODEGEN : file ../vk_helper.py line #913 2095 using namespace StreamControl; 2096 using namespace std; 2097 string final_str; 2098 string tmp_str; 2099 string extra_indent = " " + prefix; 2100 stringstream ss[2]; 2101 string stp_strs[1]; 2102 // CODEGEN : file ../vk_helper.py line #1038 2103 tmp_str = vk_print_vkextent2d(&pStruct->visibleRegion, extra_indent); 2104 ss[0] << "0x" << &pStruct->visibleRegion; 2105 stp_strs[0] = " " + prefix + "visibleRegion (addr)\n" + tmp_str; 2106 // CODEGEN : file ../vk_helper.py line #1043 2107 ss[0].str(""); 2108 // CODEGEN : file ../vk_helper.py line #1055 2109 ss[0].str("addr"); 2110 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2111 ss[1] << pStruct->refreshRate; 2112 // CODEGEN : file ../vk_helper.py line #1113 2113 final_str = final_str + prefix + "visibleRegion = " + ss[0].str() + "\n"; 2114 final_str = final_str + prefix + "refreshRate = " + ss[1].str() + "\n"; 2115 final_str = final_str + stp_strs[0]; 2116 return final_str; 2117 } 2118 // CODEGEN : file ../vk_helper.py line #907 2119 std::string vk_print_vkdisplaymodepropertieskhr(const VkDisplayModePropertiesKHR* pStruct, const std::string prefix) 2120 { 2121 // CODEGEN : file ../vk_helper.py line #913 2122 using namespace StreamControl; 2123 using namespace std; 2124 string final_str; 2125 string tmp_str; 2126 string extra_indent = " " + prefix; 2127 stringstream ss[2]; 2128 string stp_strs[1]; 2129 // CODEGEN : file ../vk_helper.py line #1038 2130 tmp_str = vk_print_vkdisplaymodeparameterskhr(&pStruct->parameters, extra_indent); 2131 ss[0] << "0x" << &pStruct->parameters; 2132 stp_strs[0] = " " + prefix + "parameters (addr)\n" + tmp_str; 2133 // CODEGEN : file ../vk_helper.py line #1043 2134 ss[0].str(""); 2135 // CODEGEN : file ../vk_helper.py line #1086 2136 ss[0] << "0x" << pStruct->displayMode; 2137 // CODEGEN : file ../vk_helper.py line #1055 2138 ss[1].str("addr"); 2139 // CODEGEN : file ../vk_helper.py line #1113 2140 final_str = final_str + prefix + "displayMode = " + ss[0].str() + "\n"; 2141 final_str = final_str + prefix + "parameters = " + ss[1].str() + "\n"; 2142 final_str = final_str + stp_strs[0]; 2143 return final_str; 2144 } 2145 // CODEGEN : file ../vk_helper.py line #907 2146 std::string vk_print_vkdisplayplanecapabilitieskhr(const VkDisplayPlaneCapabilitiesKHR* pStruct, const std::string prefix) 2147 { 2148 // CODEGEN : file ../vk_helper.py line #913 2149 using namespace StreamControl; 2150 using namespace std; 2151 string final_str; 2152 string tmp_str; 2153 string extra_indent = " " + prefix; 2154 stringstream ss[9]; 2155 string stp_strs[8]; 2156 // CODEGEN : file ../vk_helper.py line #1038 2157 tmp_str = vk_print_vkoffset2d(&pStruct->minSrcPosition, extra_indent); 2158 ss[0] << "0x" << &pStruct->minSrcPosition; 2159 stp_strs[0] = " " + prefix + "minSrcPosition (addr)\n" + tmp_str; 2160 // CODEGEN : file ../vk_helper.py line #1043 2161 ss[0].str(""); 2162 // CODEGEN : file ../vk_helper.py line #1038 2163 tmp_str = vk_print_vkoffset2d(&pStruct->maxSrcPosition, extra_indent); 2164 ss[1] << "0x" << &pStruct->maxSrcPosition; 2165 stp_strs[1] = " " + prefix + "maxSrcPosition (addr)\n" + tmp_str; 2166 // CODEGEN : file ../vk_helper.py line #1043 2167 ss[1].str(""); 2168 // CODEGEN : file ../vk_helper.py line #1038 2169 tmp_str = vk_print_vkextent2d(&pStruct->minSrcExtent, extra_indent); 2170 ss[2] << "0x" << &pStruct->minSrcExtent; 2171 stp_strs[2] = " " + prefix + "minSrcExtent (addr)\n" + tmp_str; 2172 // CODEGEN : file ../vk_helper.py line #1043 2173 ss[2].str(""); 2174 // CODEGEN : file ../vk_helper.py line #1038 2175 tmp_str = vk_print_vkextent2d(&pStruct->maxSrcExtent, extra_indent); 2176 ss[3] << "0x" << &pStruct->maxSrcExtent; 2177 stp_strs[3] = " " + prefix + "maxSrcExtent (addr)\n" + tmp_str; 2178 // CODEGEN : file ../vk_helper.py line #1043 2179 ss[3].str(""); 2180 // CODEGEN : file ../vk_helper.py line #1038 2181 tmp_str = vk_print_vkoffset2d(&pStruct->minDstPosition, extra_indent); 2182 ss[4] << "0x" << &pStruct->minDstPosition; 2183 stp_strs[4] = " " + prefix + "minDstPosition (addr)\n" + tmp_str; 2184 // CODEGEN : file ../vk_helper.py line #1043 2185 ss[4].str(""); 2186 // CODEGEN : file ../vk_helper.py line #1038 2187 tmp_str = vk_print_vkoffset2d(&pStruct->maxDstPosition, extra_indent); 2188 ss[5] << "0x" << &pStruct->maxDstPosition; 2189 stp_strs[5] = " " + prefix + "maxDstPosition (addr)\n" + tmp_str; 2190 // CODEGEN : file ../vk_helper.py line #1043 2191 ss[5].str(""); 2192 // CODEGEN : file ../vk_helper.py line #1038 2193 tmp_str = vk_print_vkextent2d(&pStruct->minDstExtent, extra_indent); 2194 ss[6] << "0x" << &pStruct->minDstExtent; 2195 stp_strs[6] = " " + prefix + "minDstExtent (addr)\n" + tmp_str; 2196 // CODEGEN : file ../vk_helper.py line #1043 2197 ss[6].str(""); 2198 // CODEGEN : file ../vk_helper.py line #1038 2199 tmp_str = vk_print_vkextent2d(&pStruct->maxDstExtent, extra_indent); 2200 ss[7] << "0x" << &pStruct->maxDstExtent; 2201 stp_strs[7] = " " + prefix + "maxDstExtent (addr)\n" + tmp_str; 2202 // CODEGEN : file ../vk_helper.py line #1043 2203 ss[7].str(""); 2204 // CODEGEN : file ../vk_helper.py line #1086 2205 ss[0] << "0x" << pStruct->supportedAlpha; 2206 // CODEGEN : file ../vk_helper.py line #1055 2207 ss[1].str("addr"); 2208 // CODEGEN : file ../vk_helper.py line #1055 2209 ss[2].str("addr"); 2210 // CODEGEN : file ../vk_helper.py line #1055 2211 ss[3].str("addr"); 2212 // CODEGEN : file ../vk_helper.py line #1055 2213 ss[4].str("addr"); 2214 // CODEGEN : file ../vk_helper.py line #1055 2215 ss[5].str("addr"); 2216 // CODEGEN : file ../vk_helper.py line #1055 2217 ss[6].str("addr"); 2218 // CODEGEN : file ../vk_helper.py line #1055 2219 ss[7].str("addr"); 2220 // CODEGEN : file ../vk_helper.py line #1055 2221 ss[8].str("addr"); 2222 // CODEGEN : file ../vk_helper.py line #1113 2223 final_str = final_str + prefix + "supportedAlpha = " + ss[0].str() + "\n"; 2224 final_str = final_str + prefix + "minSrcPosition = " + ss[1].str() + "\n"; 2225 final_str = final_str + prefix + "maxSrcPosition = " + ss[2].str() + "\n"; 2226 final_str = final_str + prefix + "minSrcExtent = " + ss[3].str() + "\n"; 2227 final_str = final_str + prefix + "maxSrcExtent = " + ss[4].str() + "\n"; 2228 final_str = final_str + prefix + "minDstPosition = " + ss[5].str() + "\n"; 2229 final_str = final_str + prefix + "maxDstPosition = " + ss[6].str() + "\n"; 2230 final_str = final_str + prefix + "minDstExtent = " + ss[7].str() + "\n"; 2231 final_str = final_str + prefix + "maxDstExtent = " + ss[8].str() + "\n"; 2232 final_str = final_str + stp_strs[7] + stp_strs[6] + stp_strs[5] + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 2233 return final_str; 2234 } 2235 // CODEGEN : file ../vk_helper.py line #907 2236 std::string vk_print_vkdisplayplanepropertieskhr(const VkDisplayPlanePropertiesKHR* pStruct, const std::string prefix) 2237 { 2238 // CODEGEN : file ../vk_helper.py line #913 2239 using namespace StreamControl; 2240 using namespace std; 2241 string final_str; 2242 string tmp_str; 2243 string extra_indent = " " + prefix; 2244 stringstream ss[2]; 2245 // CODEGEN : file ../vk_helper.py line #1086 2246 ss[0] << "0x" << pStruct->currentDisplay; 2247 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2248 ss[1] << pStruct->currentStackIndex; 2249 // CODEGEN : file ../vk_helper.py line #1113 2250 final_str = final_str + prefix + "currentDisplay = " + ss[0].str() + "\n"; 2251 final_str = final_str + prefix + "currentStackIndex = " + ss[1].str() + "\n"; 2252 return final_str; 2253 } 2254 // CODEGEN : file ../vk_helper.py line #907 2255 std::string vk_print_vkdisplaypresentinfokhr(const VkDisplayPresentInfoKHR* pStruct, const std::string prefix) 2256 { 2257 // CODEGEN : file ../vk_helper.py line #913 2258 using namespace StreamControl; 2259 using namespace std; 2260 string final_str; 2261 string tmp_str; 2262 string extra_indent = " " + prefix; 2263 stringstream ss[4]; 2264 string stp_strs[3]; 2265 // CODEGEN : file ../vk_helper.py line #1012 2266 if (pStruct->pNext) { 2267 // CODEGEN : file ../vk_helper.py line #1016 2268 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2269 ss[0] << "0x" << &pStruct->pNext; 2270 // CODEGEN : file ../vk_helper.py line #1028 2271 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2272 ss[0].str(""); 2273 } 2274 else 2275 stp_strs[0] = ""; 2276 // CODEGEN : file ../vk_helper.py line #1038 2277 tmp_str = vk_print_vkrect2d(&pStruct->srcRect, extra_indent); 2278 ss[1] << "0x" << &pStruct->srcRect; 2279 stp_strs[1] = " " + prefix + "srcRect (addr)\n" + tmp_str; 2280 // CODEGEN : file ../vk_helper.py line #1043 2281 ss[1].str(""); 2282 // CODEGEN : file ../vk_helper.py line #1038 2283 tmp_str = vk_print_vkrect2d(&pStruct->dstRect, extra_indent); 2284 ss[2] << "0x" << &pStruct->dstRect; 2285 stp_strs[2] = " " + prefix + "dstRect (addr)\n" + tmp_str; 2286 // CODEGEN : file ../vk_helper.py line #1043 2287 ss[2].str(""); 2288 // CODEGEN : file ../vk_helper.py line #1070 2289 if (StreamControl::writeAddress) 2290 ss[0] << "0x" << pStruct->pNext; 2291 else 2292 ss[0].str("address"); 2293 // CODEGEN : file ../vk_helper.py line #1055 2294 ss[1].str("addr"); 2295 // CODEGEN : file ../vk_helper.py line #1055 2296 ss[2].str("addr"); 2297 // CODEGEN : file ../vk_helper.py line #1064 2298 ss[3].str(pStruct->persistent ? "TRUE" : "FALSE"); 2299 // CODEGEN : file ../vk_helper.py line #1113 2300 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2301 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2302 final_str = final_str + prefix + "srcRect = " + ss[1].str() + "\n"; 2303 final_str = final_str + prefix + "dstRect = " + ss[2].str() + "\n"; 2304 final_str = final_str + prefix + "persistent = " + ss[3].str() + "\n"; 2305 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 2306 return final_str; 2307 } 2308 // CODEGEN : file ../vk_helper.py line #907 2309 std::string vk_print_vkdisplaypropertieskhr(const VkDisplayPropertiesKHR* pStruct, const std::string prefix) 2310 { 2311 // CODEGEN : file ../vk_helper.py line #913 2312 using namespace StreamControl; 2313 using namespace std; 2314 string final_str; 2315 string tmp_str; 2316 string extra_indent = " " + prefix; 2317 stringstream ss[7]; 2318 string stp_strs[2]; 2319 // CODEGEN : file ../vk_helper.py line #1038 2320 tmp_str = vk_print_vkextent2d(&pStruct->physicalDimensions, extra_indent); 2321 ss[0] << "0x" << &pStruct->physicalDimensions; 2322 stp_strs[0] = " " + prefix + "physicalDimensions (addr)\n" + tmp_str; 2323 // CODEGEN : file ../vk_helper.py line #1043 2324 ss[0].str(""); 2325 // CODEGEN : file ../vk_helper.py line #1038 2326 tmp_str = vk_print_vkextent2d(&pStruct->physicalResolution, extra_indent); 2327 ss[1] << "0x" << &pStruct->physicalResolution; 2328 stp_strs[1] = " " + prefix + "physicalResolution (addr)\n" + tmp_str; 2329 // CODEGEN : file ../vk_helper.py line #1043 2330 ss[1].str(""); 2331 // CODEGEN : file ../vk_helper.py line #1086 2332 ss[0] << "0x" << pStruct->display; 2333 // CODEGEN : file ../vk_helper.py line #1076 2334 if (pStruct->displayName != NULL) { 2335 ss[1] << pStruct->displayName; 2336 } else { 2337 ss[1] << ""; 2338 } 2339 // CODEGEN : file ../vk_helper.py line #1055 2340 ss[2].str("addr"); 2341 // CODEGEN : file ../vk_helper.py line #1055 2342 ss[3].str("addr"); 2343 // CODEGEN : file ../vk_helper.py line #1086 2344 ss[4] << "0x" << pStruct->supportedTransforms; 2345 // CODEGEN : file ../vk_helper.py line #1064 2346 ss[5].str(pStruct->planeReorderPossible ? "TRUE" : "FALSE"); 2347 // CODEGEN : file ../vk_helper.py line #1064 2348 ss[6].str(pStruct->persistentContent ? "TRUE" : "FALSE"); 2349 // CODEGEN : file ../vk_helper.py line #1113 2350 final_str = final_str + prefix + "display = " + ss[0].str() + "\n"; 2351 final_str = final_str + prefix + "displayName = " + ss[1].str() + "\n"; 2352 final_str = final_str + prefix + "physicalDimensions = " + ss[2].str() + "\n"; 2353 final_str = final_str + prefix + "physicalResolution = " + ss[3].str() + "\n"; 2354 final_str = final_str + prefix + "supportedTransforms = " + ss[4].str() + "\n"; 2355 final_str = final_str + prefix + "planeReorderPossible = " + ss[5].str() + "\n"; 2356 final_str = final_str + prefix + "persistentContent = " + ss[6].str() + "\n"; 2357 final_str = final_str + stp_strs[1] + stp_strs[0]; 2358 return final_str; 2359 } 2360 // CODEGEN : file ../vk_helper.py line #907 2361 std::string vk_print_vkdisplaysurfacecreateinfokhr(const VkDisplaySurfaceCreateInfoKHR* pStruct, const std::string prefix) 2362 { 2363 // CODEGEN : file ../vk_helper.py line #913 2364 using namespace StreamControl; 2365 using namespace std; 2366 string final_str; 2367 string tmp_str; 2368 string extra_indent = " " + prefix; 2369 stringstream ss[7]; 2370 string stp_strs[2]; 2371 // CODEGEN : file ../vk_helper.py line #1012 2372 if (pStruct->pNext) { 2373 // CODEGEN : file ../vk_helper.py line #1016 2374 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2375 ss[0] << "0x" << &pStruct->pNext; 2376 // CODEGEN : file ../vk_helper.py line #1028 2377 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2378 ss[0].str(""); 2379 } 2380 else 2381 stp_strs[0] = ""; 2382 // CODEGEN : file ../vk_helper.py line #1038 2383 tmp_str = vk_print_vkextent2d(&pStruct->imageExtent, extra_indent); 2384 ss[1] << "0x" << &pStruct->imageExtent; 2385 stp_strs[1] = " " + prefix + "imageExtent (addr)\n" + tmp_str; 2386 // CODEGEN : file ../vk_helper.py line #1043 2387 ss[1].str(""); 2388 // CODEGEN : file ../vk_helper.py line #1070 2389 if (StreamControl::writeAddress) 2390 ss[0] << "0x" << pStruct->pNext; 2391 else 2392 ss[0].str("address"); 2393 // CODEGEN : file ../vk_helper.py line #1086 2394 ss[1] << "0x" << pStruct->flags; 2395 // CODEGEN : file ../vk_helper.py line #1086 2396 ss[2] << "0x" << pStruct->displayMode; 2397 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2398 ss[3] << pStruct->planeIndex; 2399 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2400 ss[4] << pStruct->planeStackIndex; 2401 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2402 ss[5] << pStruct->globalAlpha; 2403 // CODEGEN : file ../vk_helper.py line #1055 2404 ss[6].str("addr"); 2405 // CODEGEN : file ../vk_helper.py line #1113 2406 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2407 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2408 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 2409 final_str = final_str + prefix + "displayMode = " + ss[2].str() + "\n"; 2410 final_str = final_str + prefix + "planeIndex = " + ss[3].str() + "\n"; 2411 final_str = final_str + prefix + "planeStackIndex = " + ss[4].str() + "\n"; 2412 final_str = final_str + prefix + "transform = " + string_VkSurfaceTransformFlagBitsKHR(pStruct->transform) + "\n"; 2413 final_str = final_str + prefix + "globalAlpha = " + ss[5].str() + "\n"; 2414 final_str = final_str + prefix + "alphaMode = " + string_VkDisplayPlaneAlphaFlagBitsKHR(pStruct->alphaMode) + "\n"; 2415 final_str = final_str + prefix + "imageExtent = " + ss[6].str() + "\n"; 2416 final_str = final_str + stp_strs[1] + stp_strs[0]; 2417 return final_str; 2418 } 2419 // CODEGEN : file ../vk_helper.py line #907 2420 std::string vk_print_vkdrawindexedindirectcommand(const VkDrawIndexedIndirectCommand* pStruct, const std::string prefix) 2421 { 2422 // CODEGEN : file ../vk_helper.py line #913 2423 using namespace StreamControl; 2424 using namespace std; 2425 string final_str; 2426 string tmp_str; 2427 string extra_indent = " " + prefix; 2428 stringstream ss[5]; 2429 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2430 ss[0] << pStruct->indexCount; 2431 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2432 ss[1] << pStruct->instanceCount; 2433 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2434 ss[2] << pStruct->firstIndex; 2435 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 2436 ss[3] << "0x" << pStruct->vertexOffset; 2437 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2438 ss[4] << pStruct->firstInstance; 2439 // CODEGEN : file ../vk_helper.py line #1113 2440 final_str = final_str + prefix + "indexCount = " + ss[0].str() + "\n"; 2441 final_str = final_str + prefix + "instanceCount = " + ss[1].str() + "\n"; 2442 final_str = final_str + prefix + "firstIndex = " + ss[2].str() + "\n"; 2443 final_str = final_str + prefix + "vertexOffset = " + ss[3].str() + "\n"; 2444 final_str = final_str + prefix + "firstInstance = " + ss[4].str() + "\n"; 2445 return final_str; 2446 } 2447 // CODEGEN : file ../vk_helper.py line #907 2448 std::string vk_print_vkdrawindirectcommand(const VkDrawIndirectCommand* pStruct, const std::string prefix) 2449 { 2450 // CODEGEN : file ../vk_helper.py line #913 2451 using namespace StreamControl; 2452 using namespace std; 2453 string final_str; 2454 string tmp_str; 2455 string extra_indent = " " + prefix; 2456 stringstream ss[4]; 2457 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2458 ss[0] << pStruct->vertexCount; 2459 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2460 ss[1] << pStruct->instanceCount; 2461 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2462 ss[2] << pStruct->firstVertex; 2463 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2464 ss[3] << pStruct->firstInstance; 2465 // CODEGEN : file ../vk_helper.py line #1113 2466 final_str = final_str + prefix + "vertexCount = " + ss[0].str() + "\n"; 2467 final_str = final_str + prefix + "instanceCount = " + ss[1].str() + "\n"; 2468 final_str = final_str + prefix + "firstVertex = " + ss[2].str() + "\n"; 2469 final_str = final_str + prefix + "firstInstance = " + ss[3].str() + "\n"; 2470 return final_str; 2471 } 2472 // CODEGEN : file ../vk_helper.py line #907 2473 std::string vk_print_vkeventcreateinfo(const VkEventCreateInfo* pStruct, const std::string prefix) 2474 { 2475 // CODEGEN : file ../vk_helper.py line #913 2476 using namespace StreamControl; 2477 using namespace std; 2478 string final_str; 2479 string tmp_str; 2480 string extra_indent = " " + prefix; 2481 stringstream ss[2]; 2482 string stp_strs[1]; 2483 // CODEGEN : file ../vk_helper.py line #1012 2484 if (pStruct->pNext) { 2485 // CODEGEN : file ../vk_helper.py line #1016 2486 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2487 ss[0] << "0x" << &pStruct->pNext; 2488 // CODEGEN : file ../vk_helper.py line #1028 2489 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2490 ss[0].str(""); 2491 } 2492 else 2493 stp_strs[0] = ""; 2494 // CODEGEN : file ../vk_helper.py line #1070 2495 if (StreamControl::writeAddress) 2496 ss[0] << "0x" << pStruct->pNext; 2497 else 2498 ss[0].str("address"); 2499 // CODEGEN : file ../vk_helper.py line #1086 2500 ss[1] << "0x" << pStruct->flags; 2501 // CODEGEN : file ../vk_helper.py line #1113 2502 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2503 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2504 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 2505 final_str = final_str + stp_strs[0]; 2506 return final_str; 2507 } 2508 // CODEGEN : file ../vk_helper.py line #907 2509 std::string vk_print_vkexportmemoryallocateinfonv(const VkExportMemoryAllocateInfoNV* pStruct, const std::string prefix) 2510 { 2511 // CODEGEN : file ../vk_helper.py line #913 2512 using namespace StreamControl; 2513 using namespace std; 2514 string final_str; 2515 string tmp_str; 2516 string extra_indent = " " + prefix; 2517 stringstream ss[2]; 2518 string stp_strs[1]; 2519 // CODEGEN : file ../vk_helper.py line #1012 2520 if (pStruct->pNext) { 2521 // CODEGEN : file ../vk_helper.py line #1016 2522 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2523 ss[0] << "0x" << &pStruct->pNext; 2524 // CODEGEN : file ../vk_helper.py line #1028 2525 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2526 ss[0].str(""); 2527 } 2528 else 2529 stp_strs[0] = ""; 2530 // CODEGEN : file ../vk_helper.py line #1070 2531 if (StreamControl::writeAddress) 2532 ss[0] << "0x" << pStruct->pNext; 2533 else 2534 ss[0].str("address"); 2535 // CODEGEN : file ../vk_helper.py line #1086 2536 ss[1] << "0x" << pStruct->handleTypes; 2537 // CODEGEN : file ../vk_helper.py line #1113 2538 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2539 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2540 final_str = final_str + prefix + "handleTypes = " + ss[1].str() + "\n"; 2541 final_str = final_str + stp_strs[0]; 2542 return final_str; 2543 } 2544 // CODEGEN : file ../vk_helper.py line #907 2545 #ifdef VK_USE_PLATFORM_WIN32_KHR 2546 std::string vk_print_vkexportmemorywin32handleinfonv(const VkExportMemoryWin32HandleInfoNV* pStruct, const std::string prefix) 2547 { 2548 // CODEGEN : file ../vk_helper.py line #913 2549 using namespace StreamControl; 2550 using namespace std; 2551 string final_str; 2552 string tmp_str; 2553 string extra_indent = " " + prefix; 2554 stringstream ss[3]; 2555 string stp_strs[1]; 2556 // CODEGEN : file ../vk_helper.py line #1012 2557 if (pStruct->pNext) { 2558 // CODEGEN : file ../vk_helper.py line #1016 2559 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2560 ss[0] << "0x" << &pStruct->pNext; 2561 // CODEGEN : file ../vk_helper.py line #1028 2562 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2563 ss[0].str(""); 2564 } 2565 else 2566 stp_strs[0] = ""; 2567 // CODEGEN : file ../vk_helper.py line #1070 2568 if (StreamControl::writeAddress) 2569 ss[0] << "0x" << pStruct->pNext; 2570 else 2571 ss[0].str("address"); 2572 // CODEGEN : file ../vk_helper.py line #1086 2573 ss[1] << "0x" << pStruct->pAttributes; 2574 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2575 ss[2] << pStruct->dwAccess; 2576 // CODEGEN : file ../vk_helper.py line #1113 2577 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2578 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2579 final_str = final_str + prefix + "pAttributes = " + ss[1].str() + "\n"; 2580 final_str = final_str + prefix + "dwAccess = " + ss[2].str() + "\n"; 2581 final_str = final_str + stp_strs[0]; 2582 return final_str; 2583 } 2584 #endif //VK_USE_PLATFORM_WIN32_KHR 2585 // CODEGEN : file ../vk_helper.py line #907 2586 std::string vk_print_vkextensionproperties(const VkExtensionProperties* pStruct, const std::string prefix) 2587 { 2588 // CODEGEN : file ../vk_helper.py line #913 2589 using namespace StreamControl; 2590 using namespace std; 2591 string final_str; 2592 string tmp_str; 2593 string extra_indent = " " + prefix; 2594 stringstream ss[2]; 2595 string stp_strs[1]; 2596 // CODEGEN : file ../vk_helper.py line #932 2597 // CODEGEN : file ../vk_helper.py line #937 2598 // CODEGEN : file ../vk_helper.py line #939 2599 stp_strs[0] = ""; 2600 stringstream index_ss; 2601 for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) { 2602 index_ss.str(""); 2603 index_ss << i; 2604 // CODEGEN : file ../vk_helper.py line #990 2605 ss[0] << pStruct->extensionName[i]; 2606 stp_strs[0] += " " + prefix + "extensionName[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 2607 // CODEGEN : file ../vk_helper.py line #1000 2608 ss[0].str(""); 2609 } 2610 // CODEGEN : file ../vk_helper.py line #1061 2611 ss[0] << "0x" << (void*)pStruct->extensionName; 2612 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2613 ss[1] << pStruct->specVersion; 2614 // CODEGEN : file ../vk_helper.py line #1113 2615 final_str = final_str + prefix + "extensionName = " + ss[0].str() + "\n"; 2616 final_str = final_str + prefix + "specVersion = " + ss[1].str() + "\n"; 2617 final_str = final_str + stp_strs[0]; 2618 return final_str; 2619 } 2620 // CODEGEN : file ../vk_helper.py line #907 2621 std::string vk_print_vkextent2d(const VkExtent2D* pStruct, const std::string prefix) 2622 { 2623 // CODEGEN : file ../vk_helper.py line #913 2624 using namespace StreamControl; 2625 using namespace std; 2626 string final_str; 2627 string tmp_str; 2628 string extra_indent = " " + prefix; 2629 stringstream ss[2]; 2630 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2631 ss[0] << pStruct->width; 2632 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2633 ss[1] << pStruct->height; 2634 // CODEGEN : file ../vk_helper.py line #1113 2635 final_str = final_str + prefix + "width = " + ss[0].str() + "\n"; 2636 final_str = final_str + prefix + "height = " + ss[1].str() + "\n"; 2637 return final_str; 2638 } 2639 // CODEGEN : file ../vk_helper.py line #907 2640 std::string vk_print_vkextent3d(const VkExtent3D* pStruct, const std::string prefix) 2641 { 2642 // CODEGEN : file ../vk_helper.py line #913 2643 using namespace StreamControl; 2644 using namespace std; 2645 string final_str; 2646 string tmp_str; 2647 string extra_indent = " " + prefix; 2648 stringstream ss[3]; 2649 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2650 ss[0] << pStruct->width; 2651 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2652 ss[1] << pStruct->height; 2653 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2654 ss[2] << pStruct->depth; 2655 // CODEGEN : file ../vk_helper.py line #1113 2656 final_str = final_str + prefix + "width = " + ss[0].str() + "\n"; 2657 final_str = final_str + prefix + "height = " + ss[1].str() + "\n"; 2658 final_str = final_str + prefix + "depth = " + ss[2].str() + "\n"; 2659 return final_str; 2660 } 2661 // CODEGEN : file ../vk_helper.py line #907 2662 std::string vk_print_vkexternalimageformatpropertiesnv(const VkExternalImageFormatPropertiesNV* pStruct, const std::string prefix) 2663 { 2664 // CODEGEN : file ../vk_helper.py line #913 2665 using namespace StreamControl; 2666 using namespace std; 2667 string final_str; 2668 string tmp_str; 2669 string extra_indent = " " + prefix; 2670 stringstream ss[4]; 2671 string stp_strs[1]; 2672 // CODEGEN : file ../vk_helper.py line #1038 2673 tmp_str = vk_print_vkimageformatproperties(&pStruct->imageFormatProperties, extra_indent); 2674 ss[0] << "0x" << &pStruct->imageFormatProperties; 2675 stp_strs[0] = " " + prefix + "imageFormatProperties (addr)\n" + tmp_str; 2676 // CODEGEN : file ../vk_helper.py line #1043 2677 ss[0].str(""); 2678 // CODEGEN : file ../vk_helper.py line #1055 2679 ss[0].str("addr"); 2680 // CODEGEN : file ../vk_helper.py line #1086 2681 ss[1] << "0x" << pStruct->externalMemoryFeatures; 2682 // CODEGEN : file ../vk_helper.py line #1086 2683 ss[2] << "0x" << pStruct->exportFromImportedHandleTypes; 2684 // CODEGEN : file ../vk_helper.py line #1086 2685 ss[3] << "0x" << pStruct->compatibleHandleTypes; 2686 // CODEGEN : file ../vk_helper.py line #1113 2687 final_str = final_str + prefix + "imageFormatProperties = " + ss[0].str() + "\n"; 2688 final_str = final_str + prefix + "externalMemoryFeatures = " + ss[1].str() + "\n"; 2689 final_str = final_str + prefix + "exportFromImportedHandleTypes = " + ss[2].str() + "\n"; 2690 final_str = final_str + prefix + "compatibleHandleTypes = " + ss[3].str() + "\n"; 2691 final_str = final_str + stp_strs[0]; 2692 return final_str; 2693 } 2694 // CODEGEN : file ../vk_helper.py line #907 2695 std::string vk_print_vkexternalmemoryimagecreateinfonv(const VkExternalMemoryImageCreateInfoNV* pStruct, const std::string prefix) 2696 { 2697 // CODEGEN : file ../vk_helper.py line #913 2698 using namespace StreamControl; 2699 using namespace std; 2700 string final_str; 2701 string tmp_str; 2702 string extra_indent = " " + prefix; 2703 stringstream ss[2]; 2704 string stp_strs[1]; 2705 // CODEGEN : file ../vk_helper.py line #1012 2706 if (pStruct->pNext) { 2707 // CODEGEN : file ../vk_helper.py line #1016 2708 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2709 ss[0] << "0x" << &pStruct->pNext; 2710 // CODEGEN : file ../vk_helper.py line #1028 2711 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2712 ss[0].str(""); 2713 } 2714 else 2715 stp_strs[0] = ""; 2716 // CODEGEN : file ../vk_helper.py line #1070 2717 if (StreamControl::writeAddress) 2718 ss[0] << "0x" << pStruct->pNext; 2719 else 2720 ss[0].str("address"); 2721 // CODEGEN : file ../vk_helper.py line #1086 2722 ss[1] << "0x" << pStruct->handleTypes; 2723 // CODEGEN : file ../vk_helper.py line #1113 2724 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2725 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2726 final_str = final_str + prefix + "handleTypes = " + ss[1].str() + "\n"; 2727 final_str = final_str + stp_strs[0]; 2728 return final_str; 2729 } 2730 // CODEGEN : file ../vk_helper.py line #907 2731 std::string vk_print_vkfencecreateinfo(const VkFenceCreateInfo* pStruct, const std::string prefix) 2732 { 2733 // CODEGEN : file ../vk_helper.py line #913 2734 using namespace StreamControl; 2735 using namespace std; 2736 string final_str; 2737 string tmp_str; 2738 string extra_indent = " " + prefix; 2739 stringstream ss[2]; 2740 string stp_strs[1]; 2741 // CODEGEN : file ../vk_helper.py line #1012 2742 if (pStruct->pNext) { 2743 // CODEGEN : file ../vk_helper.py line #1016 2744 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2745 ss[0] << "0x" << &pStruct->pNext; 2746 // CODEGEN : file ../vk_helper.py line #1028 2747 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2748 ss[0].str(""); 2749 } 2750 else 2751 stp_strs[0] = ""; 2752 // CODEGEN : file ../vk_helper.py line #1070 2753 if (StreamControl::writeAddress) 2754 ss[0] << "0x" << pStruct->pNext; 2755 else 2756 ss[0].str("address"); 2757 // CODEGEN : file ../vk_helper.py line #1086 2758 ss[1] << "0x" << pStruct->flags; 2759 // CODEGEN : file ../vk_helper.py line #1113 2760 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2761 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2762 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 2763 final_str = final_str + stp_strs[0]; 2764 return final_str; 2765 } 2766 // CODEGEN : file ../vk_helper.py line #907 2767 std::string vk_print_vkformatproperties(const VkFormatProperties* pStruct, const std::string prefix) 2768 { 2769 // CODEGEN : file ../vk_helper.py line #913 2770 using namespace StreamControl; 2771 using namespace std; 2772 string final_str; 2773 string tmp_str; 2774 string extra_indent = " " + prefix; 2775 stringstream ss[3]; 2776 // CODEGEN : file ../vk_helper.py line #1086 2777 ss[0] << "0x" << pStruct->linearTilingFeatures; 2778 // CODEGEN : file ../vk_helper.py line #1086 2779 ss[1] << "0x" << pStruct->optimalTilingFeatures; 2780 // CODEGEN : file ../vk_helper.py line #1086 2781 ss[2] << "0x" << pStruct->bufferFeatures; 2782 // CODEGEN : file ../vk_helper.py line #1113 2783 final_str = final_str + prefix + "linearTilingFeatures = " + ss[0].str() + "\n"; 2784 final_str = final_str + prefix + "optimalTilingFeatures = " + ss[1].str() + "\n"; 2785 final_str = final_str + prefix + "bufferFeatures = " + ss[2].str() + "\n"; 2786 return final_str; 2787 } 2788 // CODEGEN : file ../vk_helper.py line #907 2789 std::string vk_print_vkframebuffercreateinfo(const VkFramebufferCreateInfo* pStruct, const std::string prefix) 2790 { 2791 // CODEGEN : file ../vk_helper.py line #913 2792 using namespace StreamControl; 2793 using namespace std; 2794 string final_str; 2795 string tmp_str; 2796 string extra_indent = " " + prefix; 2797 stringstream ss[8]; 2798 string stp_strs[2]; 2799 // CODEGEN : file ../vk_helper.py line #1012 2800 if (pStruct->pNext) { 2801 // CODEGEN : file ../vk_helper.py line #1016 2802 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2803 ss[0] << "0x" << &pStruct->pNext; 2804 // CODEGEN : file ../vk_helper.py line #1028 2805 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2806 ss[0].str(""); 2807 } 2808 else 2809 stp_strs[0] = ""; 2810 // CODEGEN : file ../vk_helper.py line #932 2811 // CODEGEN : file ../vk_helper.py line #934 2812 // CODEGEN : file ../vk_helper.py line #939 2813 stp_strs[1] = ""; 2814 stringstream index_ss; 2815 if (pStruct->pAttachments) { 2816 for (uint32_t i = 0; i < pStruct->attachmentCount; i++) { 2817 index_ss.str(""); 2818 index_ss << i; 2819 // CODEGEN : file ../vk_helper.py line #990 2820 ss[1] << "0x" << pStruct->pAttachments[i]; 2821 stp_strs[1] += " " + prefix + "pAttachments[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 2822 // CODEGEN : file ../vk_helper.py line #1000 2823 ss[1].str(""); 2824 } 2825 } 2826 // CODEGEN : file ../vk_helper.py line #1070 2827 if (StreamControl::writeAddress) 2828 ss[0] << "0x" << pStruct->pNext; 2829 else 2830 ss[0].str("address"); 2831 // CODEGEN : file ../vk_helper.py line #1086 2832 ss[1] << "0x" << pStruct->flags; 2833 // CODEGEN : file ../vk_helper.py line #1086 2834 ss[2] << "0x" << pStruct->renderPass; 2835 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2836 ss[3] << pStruct->attachmentCount; 2837 // CODEGEN : file ../vk_helper.py line #1061 2838 ss[4] << "0x" << (void*)pStruct->pAttachments; 2839 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2840 ss[5] << pStruct->width; 2841 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2842 ss[6] << pStruct->height; 2843 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 2844 ss[7] << pStruct->layers; 2845 // CODEGEN : file ../vk_helper.py line #1113 2846 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 2847 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 2848 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 2849 final_str = final_str + prefix + "renderPass = " + ss[2].str() + "\n"; 2850 final_str = final_str + prefix + "attachmentCount = " + ss[3].str() + "\n"; 2851 final_str = final_str + prefix + "pAttachments = " + ss[4].str() + "\n"; 2852 final_str = final_str + prefix + "width = " + ss[5].str() + "\n"; 2853 final_str = final_str + prefix + "height = " + ss[6].str() + "\n"; 2854 final_str = final_str + prefix + "layers = " + ss[7].str() + "\n"; 2855 final_str = final_str + stp_strs[1] + stp_strs[0]; 2856 return final_str; 2857 } 2858 // CODEGEN : file ../vk_helper.py line #907 2859 std::string vk_print_vkgraphicspipelinecreateinfo(const VkGraphicsPipelineCreateInfo* pStruct, const std::string prefix) 2860 { 2861 // CODEGEN : file ../vk_helper.py line #913 2862 using namespace StreamControl; 2863 using namespace std; 2864 string final_str; 2865 string tmp_str; 2866 string extra_indent = " " + prefix; 2867 stringstream ss[18]; 2868 string stp_strs[11]; 2869 // CODEGEN : file ../vk_helper.py line #1012 2870 if (pStruct->pNext) { 2871 // CODEGEN : file ../vk_helper.py line #1016 2872 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 2873 ss[0] << "0x" << &pStruct->pNext; 2874 // CODEGEN : file ../vk_helper.py line #1028 2875 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 2876 ss[0].str(""); 2877 } 2878 else 2879 stp_strs[0] = ""; 2880 // CODEGEN : file ../vk_helper.py line #932 2881 // CODEGEN : file ../vk_helper.py line #934 2882 // CODEGEN : file ../vk_helper.py line #939 2883 stp_strs[1] = ""; 2884 stringstream index_ss; 2885 if (pStruct->pStages) { 2886 for (uint32_t i = 0; i < pStruct->stageCount; i++) { 2887 index_ss.str(""); 2888 index_ss << i; 2889 // CODEGEN : file ../vk_helper.py line #980 2890 ss[1] << "0x" << &pStruct->pStages[i]; 2891 tmp_str = vk_print_vkpipelineshaderstagecreateinfo(&pStruct->pStages[i], extra_indent); 2892 // CODEGEN : file ../vk_helper.py line #984 2893 stp_strs[1] += " " + prefix + "pStages[" + index_ss.str() + "] (addr)\n" + tmp_str; 2894 // CODEGEN : file ../vk_helper.py line #1000 2895 ss[1].str(""); 2896 } 2897 } 2898 // CODEGEN : file ../vk_helper.py line #1012 2899 if (pStruct->pVertexInputState) { 2900 // CODEGEN : file ../vk_helper.py line #1024 2901 tmp_str = vk_print_vkpipelinevertexinputstatecreateinfo(pStruct->pVertexInputState, extra_indent); 2902 ss[2] << "0x" << &pStruct->pVertexInputState; 2903 // CODEGEN : file ../vk_helper.py line #1028 2904 stp_strs[2] = " " + prefix + "pVertexInputState (addr)\n" + tmp_str; 2905 ss[2].str(""); 2906 } 2907 else 2908 stp_strs[2] = ""; 2909 // CODEGEN : file ../vk_helper.py line #1012 2910 if (pStruct->pInputAssemblyState) { 2911 // CODEGEN : file ../vk_helper.py line #1024 2912 tmp_str = vk_print_vkpipelineinputassemblystatecreateinfo(pStruct->pInputAssemblyState, extra_indent); 2913 ss[3] << "0x" << &pStruct->pInputAssemblyState; 2914 // CODEGEN : file ../vk_helper.py line #1028 2915 stp_strs[3] = " " + prefix + "pInputAssemblyState (addr)\n" + tmp_str; 2916 ss[3].str(""); 2917 } 2918 else 2919 stp_strs[3] = ""; 2920 // CODEGEN : file ../vk_helper.py line #1012 2921 if (pStruct->pTessellationState) { 2922 // CODEGEN : file ../vk_helper.py line #1024 2923 tmp_str = vk_print_vkpipelinetessellationstatecreateinfo(pStruct->pTessellationState, extra_indent); 2924 ss[4] << "0x" << &pStruct->pTessellationState; 2925 // CODEGEN : file ../vk_helper.py line #1028 2926 stp_strs[4] = " " + prefix + "pTessellationState (addr)\n" + tmp_str; 2927 ss[4].str(""); 2928 } 2929 else 2930 stp_strs[4] = ""; 2931 // CODEGEN : file ../vk_helper.py line #1012 2932 if (pStruct->pViewportState) { 2933 // CODEGEN : file ../vk_helper.py line #1024 2934 tmp_str = vk_print_vkpipelineviewportstatecreateinfo(pStruct->pViewportState, extra_indent); 2935 ss[5] << "0x" << &pStruct->pViewportState; 2936 // CODEGEN : file ../vk_helper.py line #1028 2937 stp_strs[5] = " " + prefix + "pViewportState (addr)\n" + tmp_str; 2938 ss[5].str(""); 2939 } 2940 else 2941 stp_strs[5] = ""; 2942 // CODEGEN : file ../vk_helper.py line #1012 2943 if (pStruct->pRasterizationState) { 2944 // CODEGEN : file ../vk_helper.py line #1024 2945 tmp_str = vk_print_vkpipelinerasterizationstatecreateinfo(pStruct->pRasterizationState, extra_indent); 2946 ss[6] << "0x" << &pStruct->pRasterizationState; 2947 // CODEGEN : file ../vk_helper.py line #1028 2948 stp_strs[6] = " " + prefix + "pRasterizationState (addr)\n" + tmp_str; 2949 ss[6].str(""); 2950 } 2951 else 2952 stp_strs[6] = ""; 2953 // CODEGEN : file ../vk_helper.py line #1012 2954 if (pStruct->pMultisampleState) { 2955 // CODEGEN : file ../vk_helper.py line #1024 2956 tmp_str = vk_print_vkpipelinemultisamplestatecreateinfo(pStruct->pMultisampleState, extra_indent); 2957 ss[7] << "0x" << &pStruct->pMultisampleState; 2958 // CODEGEN : file ../vk_helper.py line #1028 2959 stp_strs[7] = " " + prefix + "pMultisampleState (addr)\n" + tmp_str; 2960 ss[7].str(""); 2961 } 2962 else 2963 stp_strs[7] = ""; 2964 // CODEGEN : file ../vk_helper.py line #1012 2965 if (pStruct->pDepthStencilState) { 2966 // CODEGEN : file ../vk_helper.py line #1024 2967 tmp_str = vk_print_vkpipelinedepthstencilstatecreateinfo(pStruct->pDepthStencilState, extra_indent); 2968 ss[8] << "0x" << &pStruct->pDepthStencilState; 2969 // CODEGEN : file ../vk_helper.py line #1028 2970 stp_strs[8] = " " + prefix + "pDepthStencilState (addr)\n" + tmp_str; 2971 ss[8].str(""); 2972 } 2973 else 2974 stp_strs[8] = ""; 2975 // CODEGEN : file ../vk_helper.py line #1012 2976 if (pStruct->pColorBlendState) { 2977 // CODEGEN : file ../vk_helper.py line #1024 2978 tmp_str = vk_print_vkpipelinecolorblendstatecreateinfo(pStruct->pColorBlendState, extra_indent); 2979 ss[9] << "0x" << &pStruct->pColorBlendState; 2980 // CODEGEN : file ../vk_helper.py line #1028 2981 stp_strs[9] = " " + prefix + "pColorBlendState (addr)\n" + tmp_str; 2982 ss[9].str(""); 2983 } 2984 else 2985 stp_strs[9] = ""; 2986 // CODEGEN : file ../vk_helper.py line #1012 2987 if (pStruct->pDynamicState) { 2988 // CODEGEN : file ../vk_helper.py line #1024 2989 tmp_str = vk_print_vkpipelinedynamicstatecreateinfo(pStruct->pDynamicState, extra_indent); 2990 ss[10] << "0x" << &pStruct->pDynamicState; 2991 // CODEGEN : file ../vk_helper.py line #1028 2992 stp_strs[10] = " " + prefix + "pDynamicState (addr)\n" + tmp_str; 2993 ss[10].str(""); 2994 } 2995 else 2996 stp_strs[10] = ""; 2997 // CODEGEN : file ../vk_helper.py line #1070 2998 if (StreamControl::writeAddress) 2999 ss[0] << "0x" << pStruct->pNext; 3000 else 3001 ss[0].str("address"); 3002 // CODEGEN : file ../vk_helper.py line #1086 3003 ss[1] << "0x" << pStruct->flags; 3004 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3005 ss[2] << pStruct->stageCount; 3006 // CODEGEN : file ../vk_helper.py line #1061 3007 ss[3] << "0x" << (void*)pStruct->pStages; 3008 // CODEGEN : file ../vk_helper.py line #1086 3009 ss[4] << "0x" << pStruct->pVertexInputState; 3010 // CODEGEN : file ../vk_helper.py line #1086 3011 ss[5] << "0x" << pStruct->pInputAssemblyState; 3012 // CODEGEN : file ../vk_helper.py line #1086 3013 ss[6] << "0x" << pStruct->pTessellationState; 3014 // CODEGEN : file ../vk_helper.py line #1086 3015 ss[7] << "0x" << pStruct->pViewportState; 3016 // CODEGEN : file ../vk_helper.py line #1086 3017 ss[8] << "0x" << pStruct->pRasterizationState; 3018 // CODEGEN : file ../vk_helper.py line #1086 3019 ss[9] << "0x" << pStruct->pMultisampleState; 3020 // CODEGEN : file ../vk_helper.py line #1086 3021 ss[10] << "0x" << pStruct->pDepthStencilState; 3022 // CODEGEN : file ../vk_helper.py line #1086 3023 ss[11] << "0x" << pStruct->pColorBlendState; 3024 // CODEGEN : file ../vk_helper.py line #1086 3025 ss[12] << "0x" << pStruct->pDynamicState; 3026 // CODEGEN : file ../vk_helper.py line #1086 3027 ss[13] << "0x" << pStruct->layout; 3028 // CODEGEN : file ../vk_helper.py line #1086 3029 ss[14] << "0x" << pStruct->renderPass; 3030 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3031 ss[15] << pStruct->subpass; 3032 // CODEGEN : file ../vk_helper.py line #1086 3033 ss[16] << "0x" << pStruct->basePipelineHandle; 3034 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3035 ss[17] << pStruct->basePipelineIndex; 3036 // CODEGEN : file ../vk_helper.py line #1113 3037 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3038 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3039 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 3040 final_str = final_str + prefix + "stageCount = " + ss[2].str() + "\n"; 3041 final_str = final_str + prefix + "pStages = " + ss[3].str() + "\n"; 3042 final_str = final_str + prefix + "pVertexInputState = " + ss[4].str() + "\n"; 3043 final_str = final_str + prefix + "pInputAssemblyState = " + ss[5].str() + "\n"; 3044 final_str = final_str + prefix + "pTessellationState = " + ss[6].str() + "\n"; 3045 final_str = final_str + prefix + "pViewportState = " + ss[7].str() + "\n"; 3046 final_str = final_str + prefix + "pRasterizationState = " + ss[8].str() + "\n"; 3047 final_str = final_str + prefix + "pMultisampleState = " + ss[9].str() + "\n"; 3048 final_str = final_str + prefix + "pDepthStencilState = " + ss[10].str() + "\n"; 3049 final_str = final_str + prefix + "pColorBlendState = " + ss[11].str() + "\n"; 3050 final_str = final_str + prefix + "pDynamicState = " + ss[12].str() + "\n"; 3051 final_str = final_str + prefix + "layout = " + ss[13].str() + "\n"; 3052 final_str = final_str + prefix + "renderPass = " + ss[14].str() + "\n"; 3053 final_str = final_str + prefix + "subpass = " + ss[15].str() + "\n"; 3054 final_str = final_str + prefix + "basePipelineHandle = " + ss[16].str() + "\n"; 3055 final_str = final_str + prefix + "basePipelineIndex = " + ss[17].str() + "\n"; 3056 final_str = final_str + 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]; 3057 return final_str; 3058 } 3059 // CODEGEN : file ../vk_helper.py line #907 3060 std::string vk_print_vkimageblit(const VkImageBlit* pStruct, const std::string prefix) 3061 { 3062 // CODEGEN : file ../vk_helper.py line #913 3063 using namespace StreamControl; 3064 using namespace std; 3065 string final_str; 3066 string tmp_str; 3067 string extra_indent = " " + prefix; 3068 stringstream ss[4]; 3069 string stp_strs[4]; 3070 // CODEGEN : file ../vk_helper.py line #1038 3071 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->srcSubresource, extra_indent); 3072 ss[0] << "0x" << &pStruct->srcSubresource; 3073 stp_strs[0] = " " + prefix + "srcSubresource (addr)\n" + tmp_str; 3074 // CODEGEN : file ../vk_helper.py line #1043 3075 ss[0].str(""); 3076 // CODEGEN : file ../vk_helper.py line #932 3077 // CODEGEN : file ../vk_helper.py line #937 3078 // CODEGEN : file ../vk_helper.py line #939 3079 stp_strs[1] = ""; 3080 stringstream index_ss; 3081 for (uint32_t i = 0; i < 2; i++) { 3082 index_ss.str(""); 3083 index_ss << i; 3084 // CODEGEN : file ../vk_helper.py line #980 3085 ss[1] << "0x" << &pStruct->srcOffsets[i]; 3086 tmp_str = vk_print_vkoffset3d(&pStruct->srcOffsets[i], extra_indent); 3087 // CODEGEN : file ../vk_helper.py line #984 3088 stp_strs[1] += " " + prefix + "srcOffsets[" + index_ss.str() + "] (addr)\n" + tmp_str; 3089 // CODEGEN : file ../vk_helper.py line #1000 3090 ss[1].str(""); 3091 } 3092 // CODEGEN : file ../vk_helper.py line #1038 3093 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->dstSubresource, extra_indent); 3094 ss[2] << "0x" << &pStruct->dstSubresource; 3095 stp_strs[2] = " " + prefix + "dstSubresource (addr)\n" + tmp_str; 3096 // CODEGEN : file ../vk_helper.py line #1043 3097 ss[2].str(""); 3098 // CODEGEN : file ../vk_helper.py line #932 3099 // CODEGEN : file ../vk_helper.py line #937 3100 // CODEGEN : file ../vk_helper.py line #939 3101 stp_strs[3] = ""; 3102 for (uint32_t i = 0; i < 2; i++) { 3103 index_ss.str(""); 3104 index_ss << i; 3105 // CODEGEN : file ../vk_helper.py line #980 3106 ss[3] << "0x" << &pStruct->dstOffsets[i]; 3107 tmp_str = vk_print_vkoffset3d(&pStruct->dstOffsets[i], extra_indent); 3108 // CODEGEN : file ../vk_helper.py line #984 3109 stp_strs[3] += " " + prefix + "dstOffsets[" + index_ss.str() + "] (addr)\n" + tmp_str; 3110 // CODEGEN : file ../vk_helper.py line #1000 3111 ss[3].str(""); 3112 } 3113 // CODEGEN : file ../vk_helper.py line #1055 3114 ss[0].str("addr"); 3115 // CODEGEN : file ../vk_helper.py line #1055 3116 ss[1].str("addr"); 3117 // CODEGEN : file ../vk_helper.py line #1055 3118 ss[2].str("addr"); 3119 // CODEGEN : file ../vk_helper.py line #1055 3120 ss[3].str("addr"); 3121 // CODEGEN : file ../vk_helper.py line #1113 3122 final_str = final_str + prefix + "srcSubresource = " + ss[0].str() + "\n"; 3123 final_str = final_str + prefix + "srcOffsets = " + ss[1].str() + "\n"; 3124 final_str = final_str + prefix + "dstSubresource = " + ss[2].str() + "\n"; 3125 final_str = final_str + prefix + "dstOffsets = " + ss[3].str() + "\n"; 3126 final_str = final_str + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3127 return final_str; 3128 } 3129 // CODEGEN : file ../vk_helper.py line #907 3130 std::string vk_print_vkimagecopy(const VkImageCopy* pStruct, const std::string prefix) 3131 { 3132 // CODEGEN : file ../vk_helper.py line #913 3133 using namespace StreamControl; 3134 using namespace std; 3135 string final_str; 3136 string tmp_str; 3137 string extra_indent = " " + prefix; 3138 stringstream ss[5]; 3139 string stp_strs[5]; 3140 // CODEGEN : file ../vk_helper.py line #1038 3141 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->srcSubresource, extra_indent); 3142 ss[0] << "0x" << &pStruct->srcSubresource; 3143 stp_strs[0] = " " + prefix + "srcSubresource (addr)\n" + tmp_str; 3144 // CODEGEN : file ../vk_helper.py line #1043 3145 ss[0].str(""); 3146 // CODEGEN : file ../vk_helper.py line #1038 3147 tmp_str = vk_print_vkoffset3d(&pStruct->srcOffset, extra_indent); 3148 ss[1] << "0x" << &pStruct->srcOffset; 3149 stp_strs[1] = " " + prefix + "srcOffset (addr)\n" + tmp_str; 3150 // CODEGEN : file ../vk_helper.py line #1043 3151 ss[1].str(""); 3152 // CODEGEN : file ../vk_helper.py line #1038 3153 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->dstSubresource, extra_indent); 3154 ss[2] << "0x" << &pStruct->dstSubresource; 3155 stp_strs[2] = " " + prefix + "dstSubresource (addr)\n" + tmp_str; 3156 // CODEGEN : file ../vk_helper.py line #1043 3157 ss[2].str(""); 3158 // CODEGEN : file ../vk_helper.py line #1038 3159 tmp_str = vk_print_vkoffset3d(&pStruct->dstOffset, extra_indent); 3160 ss[3] << "0x" << &pStruct->dstOffset; 3161 stp_strs[3] = " " + prefix + "dstOffset (addr)\n" + tmp_str; 3162 // CODEGEN : file ../vk_helper.py line #1043 3163 ss[3].str(""); 3164 // CODEGEN : file ../vk_helper.py line #1038 3165 tmp_str = vk_print_vkextent3d(&pStruct->extent, extra_indent); 3166 ss[4] << "0x" << &pStruct->extent; 3167 stp_strs[4] = " " + prefix + "extent (addr)\n" + tmp_str; 3168 // CODEGEN : file ../vk_helper.py line #1043 3169 ss[4].str(""); 3170 // CODEGEN : file ../vk_helper.py line #1055 3171 ss[0].str("addr"); 3172 // CODEGEN : file ../vk_helper.py line #1055 3173 ss[1].str("addr"); 3174 // CODEGEN : file ../vk_helper.py line #1055 3175 ss[2].str("addr"); 3176 // CODEGEN : file ../vk_helper.py line #1055 3177 ss[3].str("addr"); 3178 // CODEGEN : file ../vk_helper.py line #1055 3179 ss[4].str("addr"); 3180 // CODEGEN : file ../vk_helper.py line #1113 3181 final_str = final_str + prefix + "srcSubresource = " + ss[0].str() + "\n"; 3182 final_str = final_str + prefix + "srcOffset = " + ss[1].str() + "\n"; 3183 final_str = final_str + prefix + "dstSubresource = " + ss[2].str() + "\n"; 3184 final_str = final_str + prefix + "dstOffset = " + ss[3].str() + "\n"; 3185 final_str = final_str + prefix + "extent = " + ss[4].str() + "\n"; 3186 final_str = final_str + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3187 return final_str; 3188 } 3189 // CODEGEN : file ../vk_helper.py line #907 3190 std::string vk_print_vkimagecreateinfo(const VkImageCreateInfo* pStruct, const std::string prefix) 3191 { 3192 // CODEGEN : file ../vk_helper.py line #913 3193 using namespace StreamControl; 3194 using namespace std; 3195 string final_str; 3196 string tmp_str; 3197 string extra_indent = " " + prefix; 3198 stringstream ss[8]; 3199 string stp_strs[3]; 3200 // CODEGEN : file ../vk_helper.py line #1012 3201 if (pStruct->pNext) { 3202 // CODEGEN : file ../vk_helper.py line #1016 3203 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3204 ss[0] << "0x" << &pStruct->pNext; 3205 // CODEGEN : file ../vk_helper.py line #1028 3206 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3207 ss[0].str(""); 3208 } 3209 else 3210 stp_strs[0] = ""; 3211 // CODEGEN : file ../vk_helper.py line #1038 3212 tmp_str = vk_print_vkextent3d(&pStruct->extent, extra_indent); 3213 ss[1] << "0x" << &pStruct->extent; 3214 stp_strs[1] = " " + prefix + "extent (addr)\n" + tmp_str; 3215 // CODEGEN : file ../vk_helper.py line #1043 3216 ss[1].str(""); 3217 // CODEGEN : file ../vk_helper.py line #932 3218 // CODEGEN : file ../vk_helper.py line #934 3219 // CODEGEN : file ../vk_helper.py line #939 3220 stp_strs[2] = ""; 3221 stringstream index_ss; 3222 if (pStruct->sharingMode == VK_SHARING_MODE_CONCURRENT) { 3223 if (pStruct->pQueueFamilyIndices) { 3224 for (uint32_t i = 0; i < pStruct->queueFamilyIndexCount; i++) { 3225 index_ss.str(""); 3226 index_ss << i; 3227 // CODEGEN : file ../vk_helper.py line #990 3228 ss[2] << "0x" << pStruct->pQueueFamilyIndices[i]; 3229 stp_strs[2] += " " + prefix + "pQueueFamilyIndices[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 3230 // CODEGEN : file ../vk_helper.py line #1000 3231 ss[2].str(""); 3232 } 3233 } 3234 } 3235 // CODEGEN : file ../vk_helper.py line #1070 3236 if (StreamControl::writeAddress) 3237 ss[0] << "0x" << pStruct->pNext; 3238 else 3239 ss[0].str("address"); 3240 // CODEGEN : file ../vk_helper.py line #1086 3241 ss[1] << "0x" << pStruct->flags; 3242 // CODEGEN : file ../vk_helper.py line #1055 3243 ss[2].str("addr"); 3244 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3245 ss[3] << pStruct->mipLevels; 3246 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3247 ss[4] << pStruct->arrayLayers; 3248 // CODEGEN : file ../vk_helper.py line #1086 3249 ss[5] << "0x" << pStruct->usage; 3250 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3251 ss[6] << pStruct->queueFamilyIndexCount; 3252 // CODEGEN : file ../vk_helper.py line #1061 3253 ss[7] << "0x" << (void*)pStruct->pQueueFamilyIndices; 3254 // CODEGEN : file ../vk_helper.py line #1113 3255 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3256 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3257 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 3258 final_str = final_str + prefix + "imageType = " + string_VkImageType(pStruct->imageType) + "\n"; 3259 final_str = final_str + prefix + "format = " + string_VkFormat(pStruct->format) + "\n"; 3260 final_str = final_str + prefix + "extent = " + ss[2].str() + "\n"; 3261 final_str = final_str + prefix + "mipLevels = " + ss[3].str() + "\n"; 3262 final_str = final_str + prefix + "arrayLayers = " + ss[4].str() + "\n"; 3263 final_str = final_str + prefix + "samples = " + string_VkSampleCountFlagBits(pStruct->samples) + "\n"; 3264 final_str = final_str + prefix + "tiling = " + string_VkImageTiling(pStruct->tiling) + "\n"; 3265 final_str = final_str + prefix + "usage = " + ss[5].str() + "\n"; 3266 final_str = final_str + prefix + "sharingMode = " + string_VkSharingMode(pStruct->sharingMode) + "\n"; 3267 final_str = final_str + prefix + "queueFamilyIndexCount = " + ss[6].str() + "\n"; 3268 final_str = final_str + prefix + "pQueueFamilyIndices = " + ss[7].str() + "\n"; 3269 final_str = final_str + prefix + "initialLayout = " + string_VkImageLayout(pStruct->initialLayout) + "\n"; 3270 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3271 return final_str; 3272 } 3273 // CODEGEN : file ../vk_helper.py line #907 3274 std::string vk_print_vkimageformatproperties(const VkImageFormatProperties* pStruct, const std::string prefix) 3275 { 3276 // CODEGEN : file ../vk_helper.py line #913 3277 using namespace StreamControl; 3278 using namespace std; 3279 string final_str; 3280 string tmp_str; 3281 string extra_indent = " " + prefix; 3282 stringstream ss[5]; 3283 string stp_strs[1]; 3284 // CODEGEN : file ../vk_helper.py line #1038 3285 tmp_str = vk_print_vkextent3d(&pStruct->maxExtent, extra_indent); 3286 ss[0] << "0x" << &pStruct->maxExtent; 3287 stp_strs[0] = " " + prefix + "maxExtent (addr)\n" + tmp_str; 3288 // CODEGEN : file ../vk_helper.py line #1043 3289 ss[0].str(""); 3290 // CODEGEN : file ../vk_helper.py line #1055 3291 ss[0].str("addr"); 3292 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3293 ss[1] << pStruct->maxMipLevels; 3294 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3295 ss[2] << pStruct->maxArrayLayers; 3296 // CODEGEN : file ../vk_helper.py line #1086 3297 ss[3] << "0x" << pStruct->sampleCounts; 3298 // CODEGEN : file ../vk_helper.py line #1086 3299 ss[4] << "0x" << pStruct->maxResourceSize; 3300 // CODEGEN : file ../vk_helper.py line #1113 3301 final_str = final_str + prefix + "maxExtent = " + ss[0].str() + "\n"; 3302 final_str = final_str + prefix + "maxMipLevels = " + ss[1].str() + "\n"; 3303 final_str = final_str + prefix + "maxArrayLayers = " + ss[2].str() + "\n"; 3304 final_str = final_str + prefix + "sampleCounts = " + ss[3].str() + "\n"; 3305 final_str = final_str + prefix + "maxResourceSize = " + ss[4].str() + "\n"; 3306 final_str = final_str + stp_strs[0]; 3307 return final_str; 3308 } 3309 // CODEGEN : file ../vk_helper.py line #907 3310 std::string vk_print_vkimagememorybarrier(const VkImageMemoryBarrier* pStruct, const std::string prefix) 3311 { 3312 // CODEGEN : file ../vk_helper.py line #913 3313 using namespace StreamControl; 3314 using namespace std; 3315 string final_str; 3316 string tmp_str; 3317 string extra_indent = " " + prefix; 3318 stringstream ss[7]; 3319 string stp_strs[2]; 3320 // CODEGEN : file ../vk_helper.py line #1012 3321 if (pStruct->pNext) { 3322 // CODEGEN : file ../vk_helper.py line #1016 3323 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3324 ss[0] << "0x" << &pStruct->pNext; 3325 // CODEGEN : file ../vk_helper.py line #1028 3326 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3327 ss[0].str(""); 3328 } 3329 else 3330 stp_strs[0] = ""; 3331 // CODEGEN : file ../vk_helper.py line #1038 3332 tmp_str = vk_print_vkimagesubresourcerange(&pStruct->subresourceRange, extra_indent); 3333 ss[1] << "0x" << &pStruct->subresourceRange; 3334 stp_strs[1] = " " + prefix + "subresourceRange (addr)\n" + tmp_str; 3335 // CODEGEN : file ../vk_helper.py line #1043 3336 ss[1].str(""); 3337 // CODEGEN : file ../vk_helper.py line #1070 3338 if (StreamControl::writeAddress) 3339 ss[0] << "0x" << pStruct->pNext; 3340 else 3341 ss[0].str("address"); 3342 // CODEGEN : file ../vk_helper.py line #1086 3343 ss[1] << "0x" << pStruct->srcAccessMask; 3344 // CODEGEN : file ../vk_helper.py line #1086 3345 ss[2] << "0x" << pStruct->dstAccessMask; 3346 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3347 ss[3] << pStruct->srcQueueFamilyIndex; 3348 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3349 ss[4] << pStruct->dstQueueFamilyIndex; 3350 // CODEGEN : file ../vk_helper.py line #1086 3351 ss[5] << "0x" << pStruct->image; 3352 // CODEGEN : file ../vk_helper.py line #1055 3353 ss[6].str("addr"); 3354 // CODEGEN : file ../vk_helper.py line #1113 3355 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3356 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3357 final_str = final_str + prefix + "srcAccessMask = " + ss[1].str() + "\n"; 3358 final_str = final_str + prefix + "dstAccessMask = " + ss[2].str() + "\n"; 3359 final_str = final_str + prefix + "oldLayout = " + string_VkImageLayout(pStruct->oldLayout) + "\n"; 3360 final_str = final_str + prefix + "newLayout = " + string_VkImageLayout(pStruct->newLayout) + "\n"; 3361 final_str = final_str + prefix + "srcQueueFamilyIndex = " + ss[3].str() + "\n"; 3362 final_str = final_str + prefix + "dstQueueFamilyIndex = " + ss[4].str() + "\n"; 3363 final_str = final_str + prefix + "image = " + ss[5].str() + "\n"; 3364 final_str = final_str + prefix + "subresourceRange = " + ss[6].str() + "\n"; 3365 final_str = final_str + stp_strs[1] + stp_strs[0]; 3366 return final_str; 3367 } 3368 // CODEGEN : file ../vk_helper.py line #907 3369 std::string vk_print_vkimageresolve(const VkImageResolve* pStruct, const std::string prefix) 3370 { 3371 // CODEGEN : file ../vk_helper.py line #913 3372 using namespace StreamControl; 3373 using namespace std; 3374 string final_str; 3375 string tmp_str; 3376 string extra_indent = " " + prefix; 3377 stringstream ss[5]; 3378 string stp_strs[5]; 3379 // CODEGEN : file ../vk_helper.py line #1038 3380 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->srcSubresource, extra_indent); 3381 ss[0] << "0x" << &pStruct->srcSubresource; 3382 stp_strs[0] = " " + prefix + "srcSubresource (addr)\n" + tmp_str; 3383 // CODEGEN : file ../vk_helper.py line #1043 3384 ss[0].str(""); 3385 // CODEGEN : file ../vk_helper.py line #1038 3386 tmp_str = vk_print_vkoffset3d(&pStruct->srcOffset, extra_indent); 3387 ss[1] << "0x" << &pStruct->srcOffset; 3388 stp_strs[1] = " " + prefix + "srcOffset (addr)\n" + tmp_str; 3389 // CODEGEN : file ../vk_helper.py line #1043 3390 ss[1].str(""); 3391 // CODEGEN : file ../vk_helper.py line #1038 3392 tmp_str = vk_print_vkimagesubresourcelayers(&pStruct->dstSubresource, extra_indent); 3393 ss[2] << "0x" << &pStruct->dstSubresource; 3394 stp_strs[2] = " " + prefix + "dstSubresource (addr)\n" + tmp_str; 3395 // CODEGEN : file ../vk_helper.py line #1043 3396 ss[2].str(""); 3397 // CODEGEN : file ../vk_helper.py line #1038 3398 tmp_str = vk_print_vkoffset3d(&pStruct->dstOffset, extra_indent); 3399 ss[3] << "0x" << &pStruct->dstOffset; 3400 stp_strs[3] = " " + prefix + "dstOffset (addr)\n" + tmp_str; 3401 // CODEGEN : file ../vk_helper.py line #1043 3402 ss[3].str(""); 3403 // CODEGEN : file ../vk_helper.py line #1038 3404 tmp_str = vk_print_vkextent3d(&pStruct->extent, extra_indent); 3405 ss[4] << "0x" << &pStruct->extent; 3406 stp_strs[4] = " " + prefix + "extent (addr)\n" + tmp_str; 3407 // CODEGEN : file ../vk_helper.py line #1043 3408 ss[4].str(""); 3409 // CODEGEN : file ../vk_helper.py line #1055 3410 ss[0].str("addr"); 3411 // CODEGEN : file ../vk_helper.py line #1055 3412 ss[1].str("addr"); 3413 // CODEGEN : file ../vk_helper.py line #1055 3414 ss[2].str("addr"); 3415 // CODEGEN : file ../vk_helper.py line #1055 3416 ss[3].str("addr"); 3417 // CODEGEN : file ../vk_helper.py line #1055 3418 ss[4].str("addr"); 3419 // CODEGEN : file ../vk_helper.py line #1113 3420 final_str = final_str + prefix + "srcSubresource = " + ss[0].str() + "\n"; 3421 final_str = final_str + prefix + "srcOffset = " + ss[1].str() + "\n"; 3422 final_str = final_str + prefix + "dstSubresource = " + ss[2].str() + "\n"; 3423 final_str = final_str + prefix + "dstOffset = " + ss[3].str() + "\n"; 3424 final_str = final_str + prefix + "extent = " + ss[4].str() + "\n"; 3425 final_str = final_str + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3426 return final_str; 3427 } 3428 // CODEGEN : file ../vk_helper.py line #907 3429 std::string vk_print_vkimagesubresource(const VkImageSubresource* pStruct, const std::string prefix) 3430 { 3431 // CODEGEN : file ../vk_helper.py line #913 3432 using namespace StreamControl; 3433 using namespace std; 3434 string final_str; 3435 string tmp_str; 3436 string extra_indent = " " + prefix; 3437 stringstream ss[3]; 3438 // CODEGEN : file ../vk_helper.py line #1086 3439 ss[0] << "0x" << pStruct->aspectMask; 3440 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3441 ss[1] << pStruct->mipLevel; 3442 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3443 ss[2] << pStruct->arrayLayer; 3444 // CODEGEN : file ../vk_helper.py line #1113 3445 final_str = final_str + prefix + "aspectMask = " + ss[0].str() + "\n"; 3446 final_str = final_str + prefix + "mipLevel = " + ss[1].str() + "\n"; 3447 final_str = final_str + prefix + "arrayLayer = " + ss[2].str() + "\n"; 3448 return final_str; 3449 } 3450 // CODEGEN : file ../vk_helper.py line #907 3451 std::string vk_print_vkimagesubresourcelayers(const VkImageSubresourceLayers* pStruct, const std::string prefix) 3452 { 3453 // CODEGEN : file ../vk_helper.py line #913 3454 using namespace StreamControl; 3455 using namespace std; 3456 string final_str; 3457 string tmp_str; 3458 string extra_indent = " " + prefix; 3459 stringstream ss[4]; 3460 // CODEGEN : file ../vk_helper.py line #1086 3461 ss[0] << "0x" << pStruct->aspectMask; 3462 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3463 ss[1] << pStruct->mipLevel; 3464 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3465 ss[2] << pStruct->baseArrayLayer; 3466 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3467 ss[3] << pStruct->layerCount; 3468 // CODEGEN : file ../vk_helper.py line #1113 3469 final_str = final_str + prefix + "aspectMask = " + ss[0].str() + "\n"; 3470 final_str = final_str + prefix + "mipLevel = " + ss[1].str() + "\n"; 3471 final_str = final_str + prefix + "baseArrayLayer = " + ss[2].str() + "\n"; 3472 final_str = final_str + prefix + "layerCount = " + ss[3].str() + "\n"; 3473 return final_str; 3474 } 3475 // CODEGEN : file ../vk_helper.py line #907 3476 std::string vk_print_vkimagesubresourcerange(const VkImageSubresourceRange* pStruct, const std::string prefix) 3477 { 3478 // CODEGEN : file ../vk_helper.py line #913 3479 using namespace StreamControl; 3480 using namespace std; 3481 string final_str; 3482 string tmp_str; 3483 string extra_indent = " " + prefix; 3484 stringstream ss[5]; 3485 // CODEGEN : file ../vk_helper.py line #1086 3486 ss[0] << "0x" << pStruct->aspectMask; 3487 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3488 ss[1] << pStruct->baseMipLevel; 3489 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3490 ss[2] << pStruct->levelCount; 3491 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3492 ss[3] << pStruct->baseArrayLayer; 3493 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3494 ss[4] << pStruct->layerCount; 3495 // CODEGEN : file ../vk_helper.py line #1113 3496 final_str = final_str + prefix + "aspectMask = " + ss[0].str() + "\n"; 3497 final_str = final_str + prefix + "baseMipLevel = " + ss[1].str() + "\n"; 3498 final_str = final_str + prefix + "levelCount = " + ss[2].str() + "\n"; 3499 final_str = final_str + prefix + "baseArrayLayer = " + ss[3].str() + "\n"; 3500 final_str = final_str + prefix + "layerCount = " + ss[4].str() + "\n"; 3501 return final_str; 3502 } 3503 // CODEGEN : file ../vk_helper.py line #907 3504 std::string vk_print_vkimageviewcreateinfo(const VkImageViewCreateInfo* pStruct, const std::string prefix) 3505 { 3506 // CODEGEN : file ../vk_helper.py line #913 3507 using namespace StreamControl; 3508 using namespace std; 3509 string final_str; 3510 string tmp_str; 3511 string extra_indent = " " + prefix; 3512 stringstream ss[5]; 3513 string stp_strs[3]; 3514 // CODEGEN : file ../vk_helper.py line #1012 3515 if (pStruct->pNext) { 3516 // CODEGEN : file ../vk_helper.py line #1016 3517 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3518 ss[0] << "0x" << &pStruct->pNext; 3519 // CODEGEN : file ../vk_helper.py line #1028 3520 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3521 ss[0].str(""); 3522 } 3523 else 3524 stp_strs[0] = ""; 3525 // CODEGEN : file ../vk_helper.py line #1038 3526 tmp_str = vk_print_vkcomponentmapping(&pStruct->components, extra_indent); 3527 ss[1] << "0x" << &pStruct->components; 3528 stp_strs[1] = " " + prefix + "components (addr)\n" + tmp_str; 3529 // CODEGEN : file ../vk_helper.py line #1043 3530 ss[1].str(""); 3531 // CODEGEN : file ../vk_helper.py line #1038 3532 tmp_str = vk_print_vkimagesubresourcerange(&pStruct->subresourceRange, extra_indent); 3533 ss[2] << "0x" << &pStruct->subresourceRange; 3534 stp_strs[2] = " " + prefix + "subresourceRange (addr)\n" + tmp_str; 3535 // CODEGEN : file ../vk_helper.py line #1043 3536 ss[2].str(""); 3537 // CODEGEN : file ../vk_helper.py line #1070 3538 if (StreamControl::writeAddress) 3539 ss[0] << "0x" << pStruct->pNext; 3540 else 3541 ss[0].str("address"); 3542 // CODEGEN : file ../vk_helper.py line #1086 3543 ss[1] << "0x" << pStruct->flags; 3544 // CODEGEN : file ../vk_helper.py line #1086 3545 ss[2] << "0x" << pStruct->image; 3546 // CODEGEN : file ../vk_helper.py line #1055 3547 ss[3].str("addr"); 3548 // CODEGEN : file ../vk_helper.py line #1055 3549 ss[4].str("addr"); 3550 // CODEGEN : file ../vk_helper.py line #1113 3551 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3552 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3553 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 3554 final_str = final_str + prefix + "image = " + ss[2].str() + "\n"; 3555 final_str = final_str + prefix + "viewType = " + string_VkImageViewType(pStruct->viewType) + "\n"; 3556 final_str = final_str + prefix + "format = " + string_VkFormat(pStruct->format) + "\n"; 3557 final_str = final_str + prefix + "components = " + ss[3].str() + "\n"; 3558 final_str = final_str + prefix + "subresourceRange = " + ss[4].str() + "\n"; 3559 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3560 return final_str; 3561 } 3562 // CODEGEN : file ../vk_helper.py line #907 3563 #ifdef VK_USE_PLATFORM_WIN32_KHR 3564 std::string vk_print_vkimportmemorywin32handleinfonv(const VkImportMemoryWin32HandleInfoNV* pStruct, const std::string prefix) 3565 { 3566 // CODEGEN : file ../vk_helper.py line #913 3567 using namespace StreamControl; 3568 using namespace std; 3569 string final_str; 3570 string tmp_str; 3571 string extra_indent = " " + prefix; 3572 stringstream ss[3]; 3573 string stp_strs[1]; 3574 // CODEGEN : file ../vk_helper.py line #1012 3575 if (pStruct->pNext) { 3576 // CODEGEN : file ../vk_helper.py line #1016 3577 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3578 ss[0] << "0x" << &pStruct->pNext; 3579 // CODEGEN : file ../vk_helper.py line #1028 3580 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3581 ss[0].str(""); 3582 } 3583 else 3584 stp_strs[0] = ""; 3585 // CODEGEN : file ../vk_helper.py line #1070 3586 if (StreamControl::writeAddress) 3587 ss[0] << "0x" << pStruct->pNext; 3588 else 3589 ss[0].str("address"); 3590 // CODEGEN : file ../vk_helper.py line #1086 3591 ss[1] << "0x" << pStruct->handleType; 3592 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 3593 ss[2] << "0x" << pStruct->handle; 3594 // CODEGEN : file ../vk_helper.py line #1113 3595 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3596 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3597 final_str = final_str + prefix + "handleType = " + ss[1].str() + "\n"; 3598 final_str = final_str + prefix + "handle = " + ss[2].str() + "\n"; 3599 final_str = final_str + stp_strs[0]; 3600 return final_str; 3601 } 3602 #endif //VK_USE_PLATFORM_WIN32_KHR 3603 // CODEGEN : file ../vk_helper.py line #907 3604 std::string vk_print_vkinstancecreateinfo(const VkInstanceCreateInfo* pStruct, const std::string prefix) 3605 { 3606 // CODEGEN : file ../vk_helper.py line #913 3607 using namespace StreamControl; 3608 using namespace std; 3609 string final_str; 3610 string tmp_str; 3611 string extra_indent = " " + prefix; 3612 stringstream ss[7]; 3613 string stp_strs[4]; 3614 // CODEGEN : file ../vk_helper.py line #1012 3615 if (pStruct->pNext) { 3616 // CODEGEN : file ../vk_helper.py line #1016 3617 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3618 ss[0] << "0x" << &pStruct->pNext; 3619 // CODEGEN : file ../vk_helper.py line #1028 3620 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3621 ss[0].str(""); 3622 } 3623 else 3624 stp_strs[0] = ""; 3625 // CODEGEN : file ../vk_helper.py line #1012 3626 if (pStruct->pApplicationInfo) { 3627 // CODEGEN : file ../vk_helper.py line #1024 3628 tmp_str = vk_print_vkapplicationinfo(pStruct->pApplicationInfo, extra_indent); 3629 ss[1] << "0x" << &pStruct->pApplicationInfo; 3630 // CODEGEN : file ../vk_helper.py line #1028 3631 stp_strs[1] = " " + prefix + "pApplicationInfo (addr)\n" + tmp_str; 3632 ss[1].str(""); 3633 } 3634 else 3635 stp_strs[1] = ""; 3636 // CODEGEN : file ../vk_helper.py line #932 3637 // CODEGEN : file ../vk_helper.py line #934 3638 // CODEGEN : file ../vk_helper.py line #939 3639 stp_strs[2] = ""; 3640 stringstream index_ss; 3641 if (pStruct->ppEnabledLayerNames) { 3642 for (uint32_t i = 0; i < pStruct->enabledLayerCount; i++) { 3643 index_ss.str(""); 3644 index_ss << i; 3645 // CODEGEN : file ../vk_helper.py line #990 3646 ss[2] << "0x" << pStruct->ppEnabledLayerNames[i]; 3647 stp_strs[2] += " " + prefix + "ppEnabledLayerNames[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 3648 // CODEGEN : file ../vk_helper.py line #1000 3649 ss[2].str(""); 3650 } 3651 } 3652 // CODEGEN : file ../vk_helper.py line #932 3653 // CODEGEN : file ../vk_helper.py line #934 3654 // CODEGEN : file ../vk_helper.py line #939 3655 stp_strs[3] = ""; 3656 if (pStruct->ppEnabledExtensionNames) { 3657 for (uint32_t i = 0; i < pStruct->enabledExtensionCount; i++) { 3658 index_ss.str(""); 3659 index_ss << i; 3660 // CODEGEN : file ../vk_helper.py line #990 3661 ss[3] << "0x" << pStruct->ppEnabledExtensionNames[i]; 3662 stp_strs[3] += " " + prefix + "ppEnabledExtensionNames[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 3663 // CODEGEN : file ../vk_helper.py line #1000 3664 ss[3].str(""); 3665 } 3666 } 3667 // CODEGEN : file ../vk_helper.py line #1070 3668 if (StreamControl::writeAddress) 3669 ss[0] << "0x" << pStruct->pNext; 3670 else 3671 ss[0].str("address"); 3672 // CODEGEN : file ../vk_helper.py line #1086 3673 ss[1] << "0x" << pStruct->flags; 3674 // CODEGEN : file ../vk_helper.py line #1086 3675 ss[2] << "0x" << pStruct->pApplicationInfo; 3676 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3677 ss[3] << pStruct->enabledLayerCount; 3678 // CODEGEN : file ../vk_helper.py line #1061 3679 ss[4] << "0x" << (void*)pStruct->ppEnabledLayerNames; 3680 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3681 ss[5] << pStruct->enabledExtensionCount; 3682 // CODEGEN : file ../vk_helper.py line #1061 3683 ss[6] << "0x" << (void*)pStruct->ppEnabledExtensionNames; 3684 // CODEGEN : file ../vk_helper.py line #1113 3685 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3686 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3687 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 3688 final_str = final_str + prefix + "pApplicationInfo = " + ss[2].str() + "\n"; 3689 final_str = final_str + prefix + "enabledLayerCount = " + ss[3].str() + "\n"; 3690 final_str = final_str + prefix + "ppEnabledLayerNames = " + ss[4].str() + "\n"; 3691 final_str = final_str + prefix + "enabledExtensionCount = " + ss[5].str() + "\n"; 3692 final_str = final_str + prefix + "ppEnabledExtensionNames = " + ss[6].str() + "\n"; 3693 final_str = final_str + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 3694 return final_str; 3695 } 3696 // CODEGEN : file ../vk_helper.py line #907 3697 std::string vk_print_vklayerproperties(const VkLayerProperties* pStruct, const std::string prefix) 3698 { 3699 // CODEGEN : file ../vk_helper.py line #913 3700 using namespace StreamControl; 3701 using namespace std; 3702 string final_str; 3703 string tmp_str; 3704 string extra_indent = " " + prefix; 3705 stringstream ss[4]; 3706 string stp_strs[2]; 3707 // CODEGEN : file ../vk_helper.py line #932 3708 // CODEGEN : file ../vk_helper.py line #937 3709 // CODEGEN : file ../vk_helper.py line #939 3710 stp_strs[0] = ""; 3711 stringstream index_ss; 3712 for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) { 3713 index_ss.str(""); 3714 index_ss << i; 3715 // CODEGEN : file ../vk_helper.py line #990 3716 ss[0] << pStruct->layerName[i]; 3717 stp_strs[0] += " " + prefix + "layerName[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 3718 // CODEGEN : file ../vk_helper.py line #1000 3719 ss[0].str(""); 3720 } 3721 // CODEGEN : file ../vk_helper.py line #932 3722 // CODEGEN : file ../vk_helper.py line #937 3723 // CODEGEN : file ../vk_helper.py line #939 3724 stp_strs[1] = ""; 3725 for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { 3726 index_ss.str(""); 3727 index_ss << i; 3728 // CODEGEN : file ../vk_helper.py line #990 3729 ss[1] << pStruct->description[i]; 3730 stp_strs[1] += " " + prefix + "description[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 3731 // CODEGEN : file ../vk_helper.py line #1000 3732 ss[1].str(""); 3733 } 3734 // CODEGEN : file ../vk_helper.py line #1061 3735 ss[0] << "0x" << (void*)pStruct->layerName; 3736 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3737 ss[1] << pStruct->specVersion; 3738 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3739 ss[2] << pStruct->implementationVersion; 3740 // CODEGEN : file ../vk_helper.py line #1061 3741 ss[3] << "0x" << (void*)pStruct->description; 3742 // CODEGEN : file ../vk_helper.py line #1113 3743 final_str = final_str + prefix + "layerName = " + ss[0].str() + "\n"; 3744 final_str = final_str + prefix + "specVersion = " + ss[1].str() + "\n"; 3745 final_str = final_str + prefix + "implementationVersion = " + ss[2].str() + "\n"; 3746 final_str = final_str + prefix + "description = " + ss[3].str() + "\n"; 3747 final_str = final_str + stp_strs[1] + stp_strs[0]; 3748 return final_str; 3749 } 3750 // CODEGEN : file ../vk_helper.py line #907 3751 std::string vk_print_vkmappedmemoryrange(const VkMappedMemoryRange* pStruct, const std::string prefix) 3752 { 3753 // CODEGEN : file ../vk_helper.py line #913 3754 using namespace StreamControl; 3755 using namespace std; 3756 string final_str; 3757 string tmp_str; 3758 string extra_indent = " " + prefix; 3759 stringstream ss[4]; 3760 string stp_strs[1]; 3761 // CODEGEN : file ../vk_helper.py line #1012 3762 if (pStruct->pNext) { 3763 // CODEGEN : file ../vk_helper.py line #1016 3764 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3765 ss[0] << "0x" << &pStruct->pNext; 3766 // CODEGEN : file ../vk_helper.py line #1028 3767 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3768 ss[0].str(""); 3769 } 3770 else 3771 stp_strs[0] = ""; 3772 // CODEGEN : file ../vk_helper.py line #1070 3773 if (StreamControl::writeAddress) 3774 ss[0] << "0x" << pStruct->pNext; 3775 else 3776 ss[0].str("address"); 3777 // CODEGEN : file ../vk_helper.py line #1086 3778 ss[1] << "0x" << pStruct->memory; 3779 // CODEGEN : file ../vk_helper.py line #1086 3780 ss[2] << "0x" << pStruct->offset; 3781 // CODEGEN : file ../vk_helper.py line #1086 3782 ss[3] << "0x" << pStruct->size; 3783 // CODEGEN : file ../vk_helper.py line #1113 3784 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3785 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3786 final_str = final_str + prefix + "memory = " + ss[1].str() + "\n"; 3787 final_str = final_str + prefix + "offset = " + ss[2].str() + "\n"; 3788 final_str = final_str + prefix + "size = " + ss[3].str() + "\n"; 3789 final_str = final_str + stp_strs[0]; 3790 return final_str; 3791 } 3792 // CODEGEN : file ../vk_helper.py line #907 3793 std::string vk_print_vkmemoryallocateinfo(const VkMemoryAllocateInfo* pStruct, const std::string prefix) 3794 { 3795 // CODEGEN : file ../vk_helper.py line #913 3796 using namespace StreamControl; 3797 using namespace std; 3798 string final_str; 3799 string tmp_str; 3800 string extra_indent = " " + prefix; 3801 stringstream ss[3]; 3802 string stp_strs[1]; 3803 // CODEGEN : file ../vk_helper.py line #1012 3804 if (pStruct->pNext) { 3805 // CODEGEN : file ../vk_helper.py line #1016 3806 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3807 ss[0] << "0x" << &pStruct->pNext; 3808 // CODEGEN : file ../vk_helper.py line #1028 3809 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3810 ss[0].str(""); 3811 } 3812 else 3813 stp_strs[0] = ""; 3814 // CODEGEN : file ../vk_helper.py line #1070 3815 if (StreamControl::writeAddress) 3816 ss[0] << "0x" << pStruct->pNext; 3817 else 3818 ss[0].str("address"); 3819 // CODEGEN : file ../vk_helper.py line #1086 3820 ss[1] << "0x" << pStruct->allocationSize; 3821 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3822 ss[2] << pStruct->memoryTypeIndex; 3823 // CODEGEN : file ../vk_helper.py line #1113 3824 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3825 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3826 final_str = final_str + prefix + "allocationSize = " + ss[1].str() + "\n"; 3827 final_str = final_str + prefix + "memoryTypeIndex = " + ss[2].str() + "\n"; 3828 final_str = final_str + stp_strs[0]; 3829 return final_str; 3830 } 3831 // CODEGEN : file ../vk_helper.py line #907 3832 std::string vk_print_vkmemorybarrier(const VkMemoryBarrier* pStruct, const std::string prefix) 3833 { 3834 // CODEGEN : file ../vk_helper.py line #913 3835 using namespace StreamControl; 3836 using namespace std; 3837 string final_str; 3838 string tmp_str; 3839 string extra_indent = " " + prefix; 3840 stringstream ss[3]; 3841 string stp_strs[1]; 3842 // CODEGEN : file ../vk_helper.py line #1012 3843 if (pStruct->pNext) { 3844 // CODEGEN : file ../vk_helper.py line #1016 3845 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3846 ss[0] << "0x" << &pStruct->pNext; 3847 // CODEGEN : file ../vk_helper.py line #1028 3848 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3849 ss[0].str(""); 3850 } 3851 else 3852 stp_strs[0] = ""; 3853 // CODEGEN : file ../vk_helper.py line #1070 3854 if (StreamControl::writeAddress) 3855 ss[0] << "0x" << pStruct->pNext; 3856 else 3857 ss[0].str("address"); 3858 // CODEGEN : file ../vk_helper.py line #1086 3859 ss[1] << "0x" << pStruct->srcAccessMask; 3860 // CODEGEN : file ../vk_helper.py line #1086 3861 ss[2] << "0x" << pStruct->dstAccessMask; 3862 // CODEGEN : file ../vk_helper.py line #1113 3863 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3864 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3865 final_str = final_str + prefix + "srcAccessMask = " + ss[1].str() + "\n"; 3866 final_str = final_str + prefix + "dstAccessMask = " + ss[2].str() + "\n"; 3867 final_str = final_str + stp_strs[0]; 3868 return final_str; 3869 } 3870 // CODEGEN : file ../vk_helper.py line #907 3871 std::string vk_print_vkmemoryheap(const VkMemoryHeap* pStruct, const std::string prefix) 3872 { 3873 // CODEGEN : file ../vk_helper.py line #913 3874 using namespace StreamControl; 3875 using namespace std; 3876 string final_str; 3877 string tmp_str; 3878 string extra_indent = " " + prefix; 3879 stringstream ss[2]; 3880 // CODEGEN : file ../vk_helper.py line #1086 3881 ss[0] << "0x" << pStruct->size; 3882 // CODEGEN : file ../vk_helper.py line #1086 3883 ss[1] << "0x" << pStruct->flags; 3884 // CODEGEN : file ../vk_helper.py line #1113 3885 final_str = final_str + prefix + "size = " + ss[0].str() + "\n"; 3886 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 3887 return final_str; 3888 } 3889 // CODEGEN : file ../vk_helper.py line #907 3890 std::string vk_print_vkmemoryrequirements(const VkMemoryRequirements* pStruct, const std::string prefix) 3891 { 3892 // CODEGEN : file ../vk_helper.py line #913 3893 using namespace StreamControl; 3894 using namespace std; 3895 string final_str; 3896 string tmp_str; 3897 string extra_indent = " " + prefix; 3898 stringstream ss[3]; 3899 // CODEGEN : file ../vk_helper.py line #1086 3900 ss[0] << "0x" << pStruct->size; 3901 // CODEGEN : file ../vk_helper.py line #1086 3902 ss[1] << "0x" << pStruct->alignment; 3903 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 3904 ss[2] << "0x" << pStruct->memoryTypeBits; 3905 // CODEGEN : file ../vk_helper.py line #1113 3906 final_str = final_str + prefix + "size = " + ss[0].str() + "\n"; 3907 final_str = final_str + prefix + "alignment = " + ss[1].str() + "\n"; 3908 final_str = final_str + prefix + "memoryTypeBits = " + ss[2].str() + "\n"; 3909 return final_str; 3910 } 3911 // CODEGEN : file ../vk_helper.py line #907 3912 std::string vk_print_vkmemorytype(const VkMemoryType* pStruct, const std::string prefix) 3913 { 3914 // CODEGEN : file ../vk_helper.py line #913 3915 using namespace StreamControl; 3916 using namespace std; 3917 string final_str; 3918 string tmp_str; 3919 string extra_indent = " " + prefix; 3920 stringstream ss[2]; 3921 // CODEGEN : file ../vk_helper.py line #1086 3922 ss[0] << "0x" << pStruct->propertyFlags; 3923 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3924 ss[1] << pStruct->heapIndex; 3925 // CODEGEN : file ../vk_helper.py line #1113 3926 final_str = final_str + prefix + "propertyFlags = " + ss[0].str() + "\n"; 3927 final_str = final_str + prefix + "heapIndex = " + ss[1].str() + "\n"; 3928 return final_str; 3929 } 3930 // CODEGEN : file ../vk_helper.py line #907 3931 #ifdef VK_USE_PLATFORM_MIR_KHR 3932 std::string vk_print_vkmirsurfacecreateinfokhr(const VkMirSurfaceCreateInfoKHR* pStruct, const std::string prefix) 3933 { 3934 // CODEGEN : file ../vk_helper.py line #913 3935 using namespace StreamControl; 3936 using namespace std; 3937 string final_str; 3938 string tmp_str; 3939 string extra_indent = " " + prefix; 3940 stringstream ss[4]; 3941 string stp_strs[1]; 3942 // CODEGEN : file ../vk_helper.py line #1012 3943 if (pStruct->pNext) { 3944 // CODEGEN : file ../vk_helper.py line #1016 3945 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 3946 ss[0] << "0x" << &pStruct->pNext; 3947 // CODEGEN : file ../vk_helper.py line #1028 3948 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 3949 ss[0].str(""); 3950 } 3951 else 3952 stp_strs[0] = ""; 3953 // CODEGEN : file ../vk_helper.py line #1070 3954 if (StreamControl::writeAddress) 3955 ss[0] << "0x" << pStruct->pNext; 3956 else 3957 ss[0].str("address"); 3958 // CODEGEN : file ../vk_helper.py line #1086 3959 ss[1] << "0x" << pStruct->flags; 3960 // CODEGEN : file ../vk_helper.py line #1086 3961 ss[2] << "0x" << pStruct->connection; 3962 // CODEGEN : file ../vk_helper.py line #1086 3963 ss[3] << "0x" << pStruct->mirSurface; 3964 // CODEGEN : file ../vk_helper.py line #1113 3965 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 3966 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 3967 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 3968 final_str = final_str + prefix + "connection = " + ss[2].str() + "\n"; 3969 final_str = final_str + prefix + "mirSurface = " + ss[3].str() + "\n"; 3970 final_str = final_str + stp_strs[0]; 3971 return final_str; 3972 } 3973 #endif //VK_USE_PLATFORM_MIR_KHR 3974 // CODEGEN : file ../vk_helper.py line #907 3975 std::string vk_print_vkoffset2d(const VkOffset2D* pStruct, const std::string prefix) 3976 { 3977 // CODEGEN : file ../vk_helper.py line #913 3978 using namespace StreamControl; 3979 using namespace std; 3980 string final_str; 3981 string tmp_str; 3982 string extra_indent = " " + prefix; 3983 stringstream ss[2]; 3984 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3985 ss[0] << pStruct->x; 3986 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 3987 ss[1] << pStruct->y; 3988 // CODEGEN : file ../vk_helper.py line #1113 3989 final_str = final_str + prefix + "x = " + ss[0].str() + "\n"; 3990 final_str = final_str + prefix + "y = " + ss[1].str() + "\n"; 3991 return final_str; 3992 } 3993 // CODEGEN : file ../vk_helper.py line #907 3994 std::string vk_print_vkoffset3d(const VkOffset3D* pStruct, const std::string prefix) 3995 { 3996 // CODEGEN : file ../vk_helper.py line #913 3997 using namespace StreamControl; 3998 using namespace std; 3999 string final_str; 4000 string tmp_str; 4001 string extra_indent = " " + prefix; 4002 stringstream ss[3]; 4003 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4004 ss[0] << pStruct->x; 4005 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4006 ss[1] << pStruct->y; 4007 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4008 ss[2] << pStruct->z; 4009 // CODEGEN : file ../vk_helper.py line #1113 4010 final_str = final_str + prefix + "x = " + ss[0].str() + "\n"; 4011 final_str = final_str + prefix + "y = " + ss[1].str() + "\n"; 4012 final_str = final_str + prefix + "z = " + ss[2].str() + "\n"; 4013 return final_str; 4014 } 4015 // CODEGEN : file ../vk_helper.py line #907 4016 std::string vk_print_vkphysicaldevicefeatures(const VkPhysicalDeviceFeatures* pStruct, const std::string prefix) 4017 { 4018 // CODEGEN : file ../vk_helper.py line #913 4019 using namespace StreamControl; 4020 using namespace std; 4021 string final_str; 4022 string tmp_str; 4023 string extra_indent = " " + prefix; 4024 stringstream ss[55]; 4025 // CODEGEN : file ../vk_helper.py line #1064 4026 ss[0].str(pStruct->robustBufferAccess ? "TRUE" : "FALSE"); 4027 // CODEGEN : file ../vk_helper.py line #1064 4028 ss[1].str(pStruct->fullDrawIndexUint32 ? "TRUE" : "FALSE"); 4029 // CODEGEN : file ../vk_helper.py line #1064 4030 ss[2].str(pStruct->imageCubeArray ? "TRUE" : "FALSE"); 4031 // CODEGEN : file ../vk_helper.py line #1064 4032 ss[3].str(pStruct->independentBlend ? "TRUE" : "FALSE"); 4033 // CODEGEN : file ../vk_helper.py line #1064 4034 ss[4].str(pStruct->geometryShader ? "TRUE" : "FALSE"); 4035 // CODEGEN : file ../vk_helper.py line #1064 4036 ss[5].str(pStruct->tessellationShader ? "TRUE" : "FALSE"); 4037 // CODEGEN : file ../vk_helper.py line #1064 4038 ss[6].str(pStruct->sampleRateShading ? "TRUE" : "FALSE"); 4039 // CODEGEN : file ../vk_helper.py line #1064 4040 ss[7].str(pStruct->dualSrcBlend ? "TRUE" : "FALSE"); 4041 // CODEGEN : file ../vk_helper.py line #1064 4042 ss[8].str(pStruct->logicOp ? "TRUE" : "FALSE"); 4043 // CODEGEN : file ../vk_helper.py line #1064 4044 ss[9].str(pStruct->multiDrawIndirect ? "TRUE" : "FALSE"); 4045 // CODEGEN : file ../vk_helper.py line #1064 4046 ss[10].str(pStruct->drawIndirectFirstInstance ? "TRUE" : "FALSE"); 4047 // CODEGEN : file ../vk_helper.py line #1064 4048 ss[11].str(pStruct->depthClamp ? "TRUE" : "FALSE"); 4049 // CODEGEN : file ../vk_helper.py line #1064 4050 ss[12].str(pStruct->depthBiasClamp ? "TRUE" : "FALSE"); 4051 // CODEGEN : file ../vk_helper.py line #1064 4052 ss[13].str(pStruct->fillModeNonSolid ? "TRUE" : "FALSE"); 4053 // CODEGEN : file ../vk_helper.py line #1064 4054 ss[14].str(pStruct->depthBounds ? "TRUE" : "FALSE"); 4055 // CODEGEN : file ../vk_helper.py line #1064 4056 ss[15].str(pStruct->wideLines ? "TRUE" : "FALSE"); 4057 // CODEGEN : file ../vk_helper.py line #1064 4058 ss[16].str(pStruct->largePoints ? "TRUE" : "FALSE"); 4059 // CODEGEN : file ../vk_helper.py line #1064 4060 ss[17].str(pStruct->alphaToOne ? "TRUE" : "FALSE"); 4061 // CODEGEN : file ../vk_helper.py line #1064 4062 ss[18].str(pStruct->multiViewport ? "TRUE" : "FALSE"); 4063 // CODEGEN : file ../vk_helper.py line #1064 4064 ss[19].str(pStruct->samplerAnisotropy ? "TRUE" : "FALSE"); 4065 // CODEGEN : file ../vk_helper.py line #1064 4066 ss[20].str(pStruct->textureCompressionETC2 ? "TRUE" : "FALSE"); 4067 // CODEGEN : file ../vk_helper.py line #1064 4068 ss[21].str(pStruct->textureCompressionASTC_LDR ? "TRUE" : "FALSE"); 4069 // CODEGEN : file ../vk_helper.py line #1064 4070 ss[22].str(pStruct->textureCompressionBC ? "TRUE" : "FALSE"); 4071 // CODEGEN : file ../vk_helper.py line #1064 4072 ss[23].str(pStruct->occlusionQueryPrecise ? "TRUE" : "FALSE"); 4073 // CODEGEN : file ../vk_helper.py line #1064 4074 ss[24].str(pStruct->pipelineStatisticsQuery ? "TRUE" : "FALSE"); 4075 // CODEGEN : file ../vk_helper.py line #1064 4076 ss[25].str(pStruct->vertexPipelineStoresAndAtomics ? "TRUE" : "FALSE"); 4077 // CODEGEN : file ../vk_helper.py line #1064 4078 ss[26].str(pStruct->fragmentStoresAndAtomics ? "TRUE" : "FALSE"); 4079 // CODEGEN : file ../vk_helper.py line #1064 4080 ss[27].str(pStruct->shaderTessellationAndGeometryPointSize ? "TRUE" : "FALSE"); 4081 // CODEGEN : file ../vk_helper.py line #1064 4082 ss[28].str(pStruct->shaderImageGatherExtended ? "TRUE" : "FALSE"); 4083 // CODEGEN : file ../vk_helper.py line #1064 4084 ss[29].str(pStruct->shaderStorageImageExtendedFormats ? "TRUE" : "FALSE"); 4085 // CODEGEN : file ../vk_helper.py line #1064 4086 ss[30].str(pStruct->shaderStorageImageMultisample ? "TRUE" : "FALSE"); 4087 // CODEGEN : file ../vk_helper.py line #1064 4088 ss[31].str(pStruct->shaderStorageImageReadWithoutFormat ? "TRUE" : "FALSE"); 4089 // CODEGEN : file ../vk_helper.py line #1064 4090 ss[32].str(pStruct->shaderStorageImageWriteWithoutFormat ? "TRUE" : "FALSE"); 4091 // CODEGEN : file ../vk_helper.py line #1064 4092 ss[33].str(pStruct->shaderUniformBufferArrayDynamicIndexing ? "TRUE" : "FALSE"); 4093 // CODEGEN : file ../vk_helper.py line #1064 4094 ss[34].str(pStruct->shaderSampledImageArrayDynamicIndexing ? "TRUE" : "FALSE"); 4095 // CODEGEN : file ../vk_helper.py line #1064 4096 ss[35].str(pStruct->shaderStorageBufferArrayDynamicIndexing ? "TRUE" : "FALSE"); 4097 // CODEGEN : file ../vk_helper.py line #1064 4098 ss[36].str(pStruct->shaderStorageImageArrayDynamicIndexing ? "TRUE" : "FALSE"); 4099 // CODEGEN : file ../vk_helper.py line #1064 4100 ss[37].str(pStruct->shaderClipDistance ? "TRUE" : "FALSE"); 4101 // CODEGEN : file ../vk_helper.py line #1064 4102 ss[38].str(pStruct->shaderCullDistance ? "TRUE" : "FALSE"); 4103 // CODEGEN : file ../vk_helper.py line #1064 4104 ss[39].str(pStruct->shaderFloat64 ? "TRUE" : "FALSE"); 4105 // CODEGEN : file ../vk_helper.py line #1064 4106 ss[40].str(pStruct->shaderInt64 ? "TRUE" : "FALSE"); 4107 // CODEGEN : file ../vk_helper.py line #1064 4108 ss[41].str(pStruct->shaderInt16 ? "TRUE" : "FALSE"); 4109 // CODEGEN : file ../vk_helper.py line #1064 4110 ss[42].str(pStruct->shaderResourceResidency ? "TRUE" : "FALSE"); 4111 // CODEGEN : file ../vk_helper.py line #1064 4112 ss[43].str(pStruct->shaderResourceMinLod ? "TRUE" : "FALSE"); 4113 // CODEGEN : file ../vk_helper.py line #1064 4114 ss[44].str(pStruct->sparseBinding ? "TRUE" : "FALSE"); 4115 // CODEGEN : file ../vk_helper.py line #1064 4116 ss[45].str(pStruct->sparseResidencyBuffer ? "TRUE" : "FALSE"); 4117 // CODEGEN : file ../vk_helper.py line #1064 4118 ss[46].str(pStruct->sparseResidencyImage2D ? "TRUE" : "FALSE"); 4119 // CODEGEN : file ../vk_helper.py line #1064 4120 ss[47].str(pStruct->sparseResidencyImage3D ? "TRUE" : "FALSE"); 4121 // CODEGEN : file ../vk_helper.py line #1064 4122 ss[48].str(pStruct->sparseResidency2Samples ? "TRUE" : "FALSE"); 4123 // CODEGEN : file ../vk_helper.py line #1064 4124 ss[49].str(pStruct->sparseResidency4Samples ? "TRUE" : "FALSE"); 4125 // CODEGEN : file ../vk_helper.py line #1064 4126 ss[50].str(pStruct->sparseResidency8Samples ? "TRUE" : "FALSE"); 4127 // CODEGEN : file ../vk_helper.py line #1064 4128 ss[51].str(pStruct->sparseResidency16Samples ? "TRUE" : "FALSE"); 4129 // CODEGEN : file ../vk_helper.py line #1064 4130 ss[52].str(pStruct->sparseResidencyAliased ? "TRUE" : "FALSE"); 4131 // CODEGEN : file ../vk_helper.py line #1064 4132 ss[53].str(pStruct->variableMultisampleRate ? "TRUE" : "FALSE"); 4133 // CODEGEN : file ../vk_helper.py line #1064 4134 ss[54].str(pStruct->inheritedQueries ? "TRUE" : "FALSE"); 4135 // CODEGEN : file ../vk_helper.py line #1113 4136 final_str = final_str + prefix + "robustBufferAccess = " + ss[0].str() + "\n"; 4137 final_str = final_str + prefix + "fullDrawIndexUint32 = " + ss[1].str() + "\n"; 4138 final_str = final_str + prefix + "imageCubeArray = " + ss[2].str() + "\n"; 4139 final_str = final_str + prefix + "independentBlend = " + ss[3].str() + "\n"; 4140 final_str = final_str + prefix + "geometryShader = " + ss[4].str() + "\n"; 4141 final_str = final_str + prefix + "tessellationShader = " + ss[5].str() + "\n"; 4142 final_str = final_str + prefix + "sampleRateShading = " + ss[6].str() + "\n"; 4143 final_str = final_str + prefix + "dualSrcBlend = " + ss[7].str() + "\n"; 4144 final_str = final_str + prefix + "logicOp = " + ss[8].str() + "\n"; 4145 final_str = final_str + prefix + "multiDrawIndirect = " + ss[9].str() + "\n"; 4146 final_str = final_str + prefix + "drawIndirectFirstInstance = " + ss[10].str() + "\n"; 4147 final_str = final_str + prefix + "depthClamp = " + ss[11].str() + "\n"; 4148 final_str = final_str + prefix + "depthBiasClamp = " + ss[12].str() + "\n"; 4149 final_str = final_str + prefix + "fillModeNonSolid = " + ss[13].str() + "\n"; 4150 final_str = final_str + prefix + "depthBounds = " + ss[14].str() + "\n"; 4151 final_str = final_str + prefix + "wideLines = " + ss[15].str() + "\n"; 4152 final_str = final_str + prefix + "largePoints = " + ss[16].str() + "\n"; 4153 final_str = final_str + prefix + "alphaToOne = " + ss[17].str() + "\n"; 4154 final_str = final_str + prefix + "multiViewport = " + ss[18].str() + "\n"; 4155 final_str = final_str + prefix + "samplerAnisotropy = " + ss[19].str() + "\n"; 4156 final_str = final_str + prefix + "textureCompressionETC2 = " + ss[20].str() + "\n"; 4157 final_str = final_str + prefix + "textureCompressionASTC_LDR = " + ss[21].str() + "\n"; 4158 final_str = final_str + prefix + "textureCompressionBC = " + ss[22].str() + "\n"; 4159 final_str = final_str + prefix + "occlusionQueryPrecise = " + ss[23].str() + "\n"; 4160 final_str = final_str + prefix + "pipelineStatisticsQuery = " + ss[24].str() + "\n"; 4161 final_str = final_str + prefix + "vertexPipelineStoresAndAtomics = " + ss[25].str() + "\n"; 4162 final_str = final_str + prefix + "fragmentStoresAndAtomics = " + ss[26].str() + "\n"; 4163 final_str = final_str + prefix + "shaderTessellationAndGeometryPointSize = " + ss[27].str() + "\n"; 4164 final_str = final_str + prefix + "shaderImageGatherExtended = " + ss[28].str() + "\n"; 4165 final_str = final_str + prefix + "shaderStorageImageExtendedFormats = " + ss[29].str() + "\n"; 4166 final_str = final_str + prefix + "shaderStorageImageMultisample = " + ss[30].str() + "\n"; 4167 final_str = final_str + prefix + "shaderStorageImageReadWithoutFormat = " + ss[31].str() + "\n"; 4168 final_str = final_str + prefix + "shaderStorageImageWriteWithoutFormat = " + ss[32].str() + "\n"; 4169 final_str = final_str + prefix + "shaderUniformBufferArrayDynamicIndexing = " + ss[33].str() + "\n"; 4170 final_str = final_str + prefix + "shaderSampledImageArrayDynamicIndexing = " + ss[34].str() + "\n"; 4171 final_str = final_str + prefix + "shaderStorageBufferArrayDynamicIndexing = " + ss[35].str() + "\n"; 4172 final_str = final_str + prefix + "shaderStorageImageArrayDynamicIndexing = " + ss[36].str() + "\n"; 4173 final_str = final_str + prefix + "shaderClipDistance = " + ss[37].str() + "\n"; 4174 final_str = final_str + prefix + "shaderCullDistance = " + ss[38].str() + "\n"; 4175 final_str = final_str + prefix + "shaderFloat64 = " + ss[39].str() + "\n"; 4176 final_str = final_str + prefix + "shaderInt64 = " + ss[40].str() + "\n"; 4177 final_str = final_str + prefix + "shaderInt16 = " + ss[41].str() + "\n"; 4178 final_str = final_str + prefix + "shaderResourceResidency = " + ss[42].str() + "\n"; 4179 final_str = final_str + prefix + "shaderResourceMinLod = " + ss[43].str() + "\n"; 4180 final_str = final_str + prefix + "sparseBinding = " + ss[44].str() + "\n"; 4181 final_str = final_str + prefix + "sparseResidencyBuffer = " + ss[45].str() + "\n"; 4182 final_str = final_str + prefix + "sparseResidencyImage2D = " + ss[46].str() + "\n"; 4183 final_str = final_str + prefix + "sparseResidencyImage3D = " + ss[47].str() + "\n"; 4184 final_str = final_str + prefix + "sparseResidency2Samples = " + ss[48].str() + "\n"; 4185 final_str = final_str + prefix + "sparseResidency4Samples = " + ss[49].str() + "\n"; 4186 final_str = final_str + prefix + "sparseResidency8Samples = " + ss[50].str() + "\n"; 4187 final_str = final_str + prefix + "sparseResidency16Samples = " + ss[51].str() + "\n"; 4188 final_str = final_str + prefix + "sparseResidencyAliased = " + ss[52].str() + "\n"; 4189 final_str = final_str + prefix + "variableMultisampleRate = " + ss[53].str() + "\n"; 4190 final_str = final_str + prefix + "inheritedQueries = " + ss[54].str() + "\n"; 4191 return final_str; 4192 } 4193 // CODEGEN : file ../vk_helper.py line #907 4194 std::string vk_print_vkphysicaldevicelimits(const VkPhysicalDeviceLimits* pStruct, const std::string prefix) 4195 { 4196 // CODEGEN : file ../vk_helper.py line #913 4197 using namespace StreamControl; 4198 using namespace std; 4199 string final_str; 4200 string tmp_str; 4201 string extra_indent = " " + prefix; 4202 stringstream ss[106]; 4203 string stp_strs[6]; 4204 // CODEGEN : file ../vk_helper.py line #932 4205 // CODEGEN : file ../vk_helper.py line #937 4206 // CODEGEN : file ../vk_helper.py line #939 4207 stp_strs[0] = ""; 4208 stringstream index_ss; 4209 for (uint32_t i = 0; i < 3; i++) { 4210 index_ss.str(""); 4211 index_ss << i; 4212 // CODEGEN : file ../vk_helper.py line #990 4213 ss[0] << pStruct->maxComputeWorkGroupCount[i]; 4214 stp_strs[0] += " " + prefix + "maxComputeWorkGroupCount[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 4215 // CODEGEN : file ../vk_helper.py line #1000 4216 ss[0].str(""); 4217 } 4218 // CODEGEN : file ../vk_helper.py line #932 4219 // CODEGEN : file ../vk_helper.py line #937 4220 // CODEGEN : file ../vk_helper.py line #939 4221 stp_strs[1] = ""; 4222 for (uint32_t i = 0; i < 3; i++) { 4223 index_ss.str(""); 4224 index_ss << i; 4225 // CODEGEN : file ../vk_helper.py line #990 4226 ss[1] << pStruct->maxComputeWorkGroupSize[i]; 4227 stp_strs[1] += " " + prefix + "maxComputeWorkGroupSize[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 4228 // CODEGEN : file ../vk_helper.py line #1000 4229 ss[1].str(""); 4230 } 4231 // CODEGEN : file ../vk_helper.py line #932 4232 // CODEGEN : file ../vk_helper.py line #937 4233 // CODEGEN : file ../vk_helper.py line #939 4234 stp_strs[2] = ""; 4235 for (uint32_t i = 0; i < 2; i++) { 4236 index_ss.str(""); 4237 index_ss << i; 4238 // CODEGEN : file ../vk_helper.py line #990 4239 ss[2] << pStruct->maxViewportDimensions[i]; 4240 stp_strs[2] += " " + prefix + "maxViewportDimensions[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 4241 // CODEGEN : file ../vk_helper.py line #1000 4242 ss[2].str(""); 4243 } 4244 // CODEGEN : file ../vk_helper.py line #932 4245 // CODEGEN : file ../vk_helper.py line #937 4246 // CODEGEN : file ../vk_helper.py line #939 4247 stp_strs[3] = ""; 4248 for (uint32_t i = 0; i < 2; i++) { 4249 index_ss.str(""); 4250 index_ss << i; 4251 // CODEGEN : file ../vk_helper.py line #990 4252 ss[3] << pStruct->viewportBoundsRange[i]; 4253 stp_strs[3] += " " + prefix + "viewportBoundsRange[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 4254 // CODEGEN : file ../vk_helper.py line #1000 4255 ss[3].str(""); 4256 } 4257 // CODEGEN : file ../vk_helper.py line #932 4258 // CODEGEN : file ../vk_helper.py line #937 4259 // CODEGEN : file ../vk_helper.py line #939 4260 stp_strs[4] = ""; 4261 for (uint32_t i = 0; i < 2; i++) { 4262 index_ss.str(""); 4263 index_ss << i; 4264 // CODEGEN : file ../vk_helper.py line #990 4265 ss[4] << pStruct->pointSizeRange[i]; 4266 stp_strs[4] += " " + prefix + "pointSizeRange[" + index_ss.str() + "] = " + ss[4].str() + "\n"; 4267 // CODEGEN : file ../vk_helper.py line #1000 4268 ss[4].str(""); 4269 } 4270 // CODEGEN : file ../vk_helper.py line #932 4271 // CODEGEN : file ../vk_helper.py line #937 4272 // CODEGEN : file ../vk_helper.py line #939 4273 stp_strs[5] = ""; 4274 for (uint32_t i = 0; i < 2; i++) { 4275 index_ss.str(""); 4276 index_ss << i; 4277 // CODEGEN : file ../vk_helper.py line #990 4278 ss[5] << pStruct->lineWidthRange[i]; 4279 stp_strs[5] += " " + prefix + "lineWidthRange[" + index_ss.str() + "] = " + ss[5].str() + "\n"; 4280 // CODEGEN : file ../vk_helper.py line #1000 4281 ss[5].str(""); 4282 } 4283 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4284 ss[0] << pStruct->maxImageDimension1D; 4285 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4286 ss[1] << pStruct->maxImageDimension2D; 4287 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4288 ss[2] << pStruct->maxImageDimension3D; 4289 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4290 ss[3] << pStruct->maxImageDimensionCube; 4291 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4292 ss[4] << pStruct->maxImageArrayLayers; 4293 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4294 ss[5] << "0x" << pStruct->maxTexelBufferElements; 4295 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4296 ss[6] << "0x" << pStruct->maxUniformBufferRange; 4297 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4298 ss[7] << "0x" << pStruct->maxStorageBufferRange; 4299 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4300 ss[8] << pStruct->maxPushConstantsSize; 4301 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4302 ss[9] << pStruct->maxMemoryAllocationCount; 4303 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4304 ss[10] << pStruct->maxSamplerAllocationCount; 4305 // CODEGEN : file ../vk_helper.py line #1086 4306 ss[11] << "0x" << pStruct->bufferImageGranularity; 4307 // CODEGEN : file ../vk_helper.py line #1086 4308 ss[12] << "0x" << pStruct->sparseAddressSpaceSize; 4309 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4310 ss[13] << pStruct->maxBoundDescriptorSets; 4311 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4312 ss[14] << pStruct->maxPerStageDescriptorSamplers; 4313 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4314 ss[15] << "0x" << pStruct->maxPerStageDescriptorUniformBuffers; 4315 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4316 ss[16] << "0x" << pStruct->maxPerStageDescriptorStorageBuffers; 4317 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4318 ss[17] << pStruct->maxPerStageDescriptorSampledImages; 4319 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4320 ss[18] << pStruct->maxPerStageDescriptorStorageImages; 4321 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4322 ss[19] << pStruct->maxPerStageDescriptorInputAttachments; 4323 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4324 ss[20] << pStruct->maxPerStageResources; 4325 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4326 ss[21] << pStruct->maxDescriptorSetSamplers; 4327 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4328 ss[22] << "0x" << pStruct->maxDescriptorSetUniformBuffers; 4329 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4330 ss[23] << "0x" << pStruct->maxDescriptorSetUniformBuffersDynamic; 4331 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4332 ss[24] << "0x" << pStruct->maxDescriptorSetStorageBuffers; 4333 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4334 ss[25] << "0x" << pStruct->maxDescriptorSetStorageBuffersDynamic; 4335 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4336 ss[26] << pStruct->maxDescriptorSetSampledImages; 4337 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4338 ss[27] << pStruct->maxDescriptorSetStorageImages; 4339 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4340 ss[28] << pStruct->maxDescriptorSetInputAttachments; 4341 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4342 ss[29] << pStruct->maxVertexInputAttributes; 4343 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4344 ss[30] << pStruct->maxVertexInputBindings; 4345 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4346 ss[31] << "0x" << pStruct->maxVertexInputAttributeOffset; 4347 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4348 ss[32] << pStruct->maxVertexInputBindingStride; 4349 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4350 ss[33] << pStruct->maxVertexOutputComponents; 4351 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4352 ss[34] << pStruct->maxTessellationGenerationLevel; 4353 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4354 ss[35] << pStruct->maxTessellationPatchSize; 4355 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4356 ss[36] << pStruct->maxTessellationControlPerVertexInputComponents; 4357 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4358 ss[37] << pStruct->maxTessellationControlPerVertexOutputComponents; 4359 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4360 ss[38] << pStruct->maxTessellationControlPerPatchOutputComponents; 4361 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4362 ss[39] << pStruct->maxTessellationControlTotalOutputComponents; 4363 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4364 ss[40] << pStruct->maxTessellationEvaluationInputComponents; 4365 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4366 ss[41] << pStruct->maxTessellationEvaluationOutputComponents; 4367 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4368 ss[42] << pStruct->maxGeometryShaderInvocations; 4369 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4370 ss[43] << pStruct->maxGeometryInputComponents; 4371 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4372 ss[44] << pStruct->maxGeometryOutputComponents; 4373 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4374 ss[45] << pStruct->maxGeometryOutputVertices; 4375 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4376 ss[46] << pStruct->maxGeometryTotalOutputComponents; 4377 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4378 ss[47] << pStruct->maxFragmentInputComponents; 4379 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4380 ss[48] << pStruct->maxFragmentOutputAttachments; 4381 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4382 ss[49] << pStruct->maxFragmentDualSrcAttachments; 4383 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4384 ss[50] << pStruct->maxFragmentCombinedOutputResources; 4385 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4386 ss[51] << pStruct->maxComputeSharedMemorySize; 4387 // CODEGEN : file ../vk_helper.py line #1061 4388 ss[52] << "0x" << (void*)pStruct->maxComputeWorkGroupCount; 4389 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4390 ss[53] << pStruct->maxComputeWorkGroupInvocations; 4391 // CODEGEN : file ../vk_helper.py line #1061 4392 ss[54] << "0x" << (void*)pStruct->maxComputeWorkGroupSize; 4393 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4394 ss[55] << "0x" << pStruct->subPixelPrecisionBits; 4395 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4396 ss[56] << "0x" << pStruct->subTexelPrecisionBits; 4397 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4398 ss[57] << "0x" << pStruct->mipmapPrecisionBits; 4399 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4400 ss[58] << pStruct->maxDrawIndexedIndexValue; 4401 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4402 ss[59] << pStruct->maxDrawIndirectCount; 4403 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4404 ss[60] << pStruct->maxSamplerLodBias; 4405 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4406 ss[61] << pStruct->maxSamplerAnisotropy; 4407 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4408 ss[62] << pStruct->maxViewports; 4409 // CODEGEN : file ../vk_helper.py line #1061 4410 ss[63] << "0x" << (void*)pStruct->maxViewportDimensions; 4411 // CODEGEN : file ../vk_helper.py line #1061 4412 ss[64] << "0x" << (void*)pStruct->viewportBoundsRange; 4413 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4414 ss[65] << "0x" << pStruct->viewportSubPixelBits; 4415 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4416 ss[66] << pStruct->minMemoryMapAlignment; 4417 // CODEGEN : file ../vk_helper.py line #1086 4418 ss[67] << "0x" << pStruct->minTexelBufferOffsetAlignment; 4419 // CODEGEN : file ../vk_helper.py line #1086 4420 ss[68] << "0x" << pStruct->minUniformBufferOffsetAlignment; 4421 // CODEGEN : file ../vk_helper.py line #1086 4422 ss[69] << "0x" << pStruct->minStorageBufferOffsetAlignment; 4423 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4424 ss[70] << "0x" << pStruct->minTexelOffset; 4425 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4426 ss[71] << "0x" << pStruct->maxTexelOffset; 4427 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4428 ss[72] << "0x" << pStruct->minTexelGatherOffset; 4429 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4430 ss[73] << "0x" << pStruct->maxTexelGatherOffset; 4431 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4432 ss[74] << "0x" << pStruct->minInterpolationOffset; 4433 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4434 ss[75] << "0x" << pStruct->maxInterpolationOffset; 4435 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4436 ss[76] << "0x" << pStruct->subPixelInterpolationOffsetBits; 4437 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4438 ss[77] << "0x" << pStruct->maxFramebufferWidth; 4439 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4440 ss[78] << "0x" << pStruct->maxFramebufferHeight; 4441 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4442 ss[79] << "0x" << pStruct->maxFramebufferLayers; 4443 // CODEGEN : file ../vk_helper.py line #1086 4444 ss[80] << "0x" << pStruct->framebufferColorSampleCounts; 4445 // CODEGEN : file ../vk_helper.py line #1086 4446 ss[81] << "0x" << pStruct->framebufferDepthSampleCounts; 4447 // CODEGEN : file ../vk_helper.py line #1086 4448 ss[82] << "0x" << pStruct->framebufferStencilSampleCounts; 4449 // CODEGEN : file ../vk_helper.py line #1086 4450 ss[83] << "0x" << pStruct->framebufferNoAttachmentsSampleCounts; 4451 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4452 ss[84] << pStruct->maxColorAttachments; 4453 // CODEGEN : file ../vk_helper.py line #1086 4454 ss[85] << "0x" << pStruct->sampledImageColorSampleCounts; 4455 // CODEGEN : file ../vk_helper.py line #1086 4456 ss[86] << "0x" << pStruct->sampledImageIntegerSampleCounts; 4457 // CODEGEN : file ../vk_helper.py line #1086 4458 ss[87] << "0x" << pStruct->sampledImageDepthSampleCounts; 4459 // CODEGEN : file ../vk_helper.py line #1086 4460 ss[88] << "0x" << pStruct->sampledImageStencilSampleCounts; 4461 // CODEGEN : file ../vk_helper.py line #1086 4462 ss[89] << "0x" << pStruct->storageImageSampleCounts; 4463 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4464 ss[90] << "0x" << pStruct->maxSampleMaskWords; 4465 // CODEGEN : file ../vk_helper.py line #1064 4466 ss[91].str(pStruct->timestampComputeAndGraphics ? "TRUE" : "FALSE"); 4467 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4468 ss[92] << pStruct->timestampPeriod; 4469 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4470 ss[93] << pStruct->maxClipDistances; 4471 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4472 ss[94] << pStruct->maxCullDistances; 4473 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4474 ss[95] << pStruct->maxCombinedClipAndCullDistances; 4475 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4476 ss[96] << pStruct->discreteQueuePriorities; 4477 // CODEGEN : file ../vk_helper.py line #1061 4478 ss[97] << "0x" << (void*)pStruct->pointSizeRange; 4479 // CODEGEN : file ../vk_helper.py line #1061 4480 ss[98] << "0x" << (void*)pStruct->lineWidthRange; 4481 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4482 ss[99] << pStruct->pointSizeGranularity; 4483 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4484 ss[100] << pStruct->lineWidthGranularity; 4485 // CODEGEN : file ../vk_helper.py line #1064 4486 ss[101].str(pStruct->strictLines ? "TRUE" : "FALSE"); 4487 // CODEGEN : file ../vk_helper.py line #1064 4488 ss[102].str(pStruct->standardSampleLocations ? "TRUE" : "FALSE"); 4489 // CODEGEN : file ../vk_helper.py line #1086 4490 ss[103] << "0x" << pStruct->optimalBufferCopyOffsetAlignment; 4491 // CODEGEN : file ../vk_helper.py line #1086 4492 ss[104] << "0x" << pStruct->optimalBufferCopyRowPitchAlignment; 4493 // CODEGEN : file ../vk_helper.py line #1086 4494 ss[105] << "0x" << pStruct->nonCoherentAtomSize; 4495 // CODEGEN : file ../vk_helper.py line #1113 4496 final_str = final_str + prefix + "maxImageDimension1D = " + ss[0].str() + "\n"; 4497 final_str = final_str + prefix + "maxImageDimension2D = " + ss[1].str() + "\n"; 4498 final_str = final_str + prefix + "maxImageDimension3D = " + ss[2].str() + "\n"; 4499 final_str = final_str + prefix + "maxImageDimensionCube = " + ss[3].str() + "\n"; 4500 final_str = final_str + prefix + "maxImageArrayLayers = " + ss[4].str() + "\n"; 4501 final_str = final_str + prefix + "maxTexelBufferElements = " + ss[5].str() + "\n"; 4502 final_str = final_str + prefix + "maxUniformBufferRange = " + ss[6].str() + "\n"; 4503 final_str = final_str + prefix + "maxStorageBufferRange = " + ss[7].str() + "\n"; 4504 final_str = final_str + prefix + "maxPushConstantsSize = " + ss[8].str() + "\n"; 4505 final_str = final_str + prefix + "maxMemoryAllocationCount = " + ss[9].str() + "\n"; 4506 final_str = final_str + prefix + "maxSamplerAllocationCount = " + ss[10].str() + "\n"; 4507 final_str = final_str + prefix + "bufferImageGranularity = " + ss[11].str() + "\n"; 4508 final_str = final_str + prefix + "sparseAddressSpaceSize = " + ss[12].str() + "\n"; 4509 final_str = final_str + prefix + "maxBoundDescriptorSets = " + ss[13].str() + "\n"; 4510 final_str = final_str + prefix + "maxPerStageDescriptorSamplers = " + ss[14].str() + "\n"; 4511 final_str = final_str + prefix + "maxPerStageDescriptorUniformBuffers = " + ss[15].str() + "\n"; 4512 final_str = final_str + prefix + "maxPerStageDescriptorStorageBuffers = " + ss[16].str() + "\n"; 4513 final_str = final_str + prefix + "maxPerStageDescriptorSampledImages = " + ss[17].str() + "\n"; 4514 final_str = final_str + prefix + "maxPerStageDescriptorStorageImages = " + ss[18].str() + "\n"; 4515 final_str = final_str + prefix + "maxPerStageDescriptorInputAttachments = " + ss[19].str() + "\n"; 4516 final_str = final_str + prefix + "maxPerStageResources = " + ss[20].str() + "\n"; 4517 final_str = final_str + prefix + "maxDescriptorSetSamplers = " + ss[21].str() + "\n"; 4518 final_str = final_str + prefix + "maxDescriptorSetUniformBuffers = " + ss[22].str() + "\n"; 4519 final_str = final_str + prefix + "maxDescriptorSetUniformBuffersDynamic = " + ss[23].str() + "\n"; 4520 final_str = final_str + prefix + "maxDescriptorSetStorageBuffers = " + ss[24].str() + "\n"; 4521 final_str = final_str + prefix + "maxDescriptorSetStorageBuffersDynamic = " + ss[25].str() + "\n"; 4522 final_str = final_str + prefix + "maxDescriptorSetSampledImages = " + ss[26].str() + "\n"; 4523 final_str = final_str + prefix + "maxDescriptorSetStorageImages = " + ss[27].str() + "\n"; 4524 final_str = final_str + prefix + "maxDescriptorSetInputAttachments = " + ss[28].str() + "\n"; 4525 final_str = final_str + prefix + "maxVertexInputAttributes = " + ss[29].str() + "\n"; 4526 final_str = final_str + prefix + "maxVertexInputBindings = " + ss[30].str() + "\n"; 4527 final_str = final_str + prefix + "maxVertexInputAttributeOffset = " + ss[31].str() + "\n"; 4528 final_str = final_str + prefix + "maxVertexInputBindingStride = " + ss[32].str() + "\n"; 4529 final_str = final_str + prefix + "maxVertexOutputComponents = " + ss[33].str() + "\n"; 4530 final_str = final_str + prefix + "maxTessellationGenerationLevel = " + ss[34].str() + "\n"; 4531 final_str = final_str + prefix + "maxTessellationPatchSize = " + ss[35].str() + "\n"; 4532 final_str = final_str + prefix + "maxTessellationControlPerVertexInputComponents = " + ss[36].str() + "\n"; 4533 final_str = final_str + prefix + "maxTessellationControlPerVertexOutputComponents = " + ss[37].str() + "\n"; 4534 final_str = final_str + prefix + "maxTessellationControlPerPatchOutputComponents = " + ss[38].str() + "\n"; 4535 final_str = final_str + prefix + "maxTessellationControlTotalOutputComponents = " + ss[39].str() + "\n"; 4536 final_str = final_str + prefix + "maxTessellationEvaluationInputComponents = " + ss[40].str() + "\n"; 4537 final_str = final_str + prefix + "maxTessellationEvaluationOutputComponents = " + ss[41].str() + "\n"; 4538 final_str = final_str + prefix + "maxGeometryShaderInvocations = " + ss[42].str() + "\n"; 4539 final_str = final_str + prefix + "maxGeometryInputComponents = " + ss[43].str() + "\n"; 4540 final_str = final_str + prefix + "maxGeometryOutputComponents = " + ss[44].str() + "\n"; 4541 final_str = final_str + prefix + "maxGeometryOutputVertices = " + ss[45].str() + "\n"; 4542 final_str = final_str + prefix + "maxGeometryTotalOutputComponents = " + ss[46].str() + "\n"; 4543 final_str = final_str + prefix + "maxFragmentInputComponents = " + ss[47].str() + "\n"; 4544 final_str = final_str + prefix + "maxFragmentOutputAttachments = " + ss[48].str() + "\n"; 4545 final_str = final_str + prefix + "maxFragmentDualSrcAttachments = " + ss[49].str() + "\n"; 4546 final_str = final_str + prefix + "maxFragmentCombinedOutputResources = " + ss[50].str() + "\n"; 4547 final_str = final_str + prefix + "maxComputeSharedMemorySize = " + ss[51].str() + "\n"; 4548 final_str = final_str + prefix + "maxComputeWorkGroupCount = " + ss[52].str() + "\n"; 4549 final_str = final_str + prefix + "maxComputeWorkGroupInvocations = " + ss[53].str() + "\n"; 4550 final_str = final_str + prefix + "maxComputeWorkGroupSize = " + ss[54].str() + "\n"; 4551 final_str = final_str + prefix + "subPixelPrecisionBits = " + ss[55].str() + "\n"; 4552 final_str = final_str + prefix + "subTexelPrecisionBits = " + ss[56].str() + "\n"; 4553 final_str = final_str + prefix + "mipmapPrecisionBits = " + ss[57].str() + "\n"; 4554 final_str = final_str + prefix + "maxDrawIndexedIndexValue = " + ss[58].str() + "\n"; 4555 final_str = final_str + prefix + "maxDrawIndirectCount = " + ss[59].str() + "\n"; 4556 final_str = final_str + prefix + "maxSamplerLodBias = " + ss[60].str() + "\n"; 4557 final_str = final_str + prefix + "maxSamplerAnisotropy = " + ss[61].str() + "\n"; 4558 final_str = final_str + prefix + "maxViewports = " + ss[62].str() + "\n"; 4559 final_str = final_str + prefix + "maxViewportDimensions = " + ss[63].str() + "\n"; 4560 final_str = final_str + prefix + "viewportBoundsRange = " + ss[64].str() + "\n"; 4561 final_str = final_str + prefix + "viewportSubPixelBits = " + ss[65].str() + "\n"; 4562 final_str = final_str + prefix + "minMemoryMapAlignment = " + ss[66].str() + "\n"; 4563 final_str = final_str + prefix + "minTexelBufferOffsetAlignment = " + ss[67].str() + "\n"; 4564 final_str = final_str + prefix + "minUniformBufferOffsetAlignment = " + ss[68].str() + "\n"; 4565 final_str = final_str + prefix + "minStorageBufferOffsetAlignment = " + ss[69].str() + "\n"; 4566 final_str = final_str + prefix + "minTexelOffset = " + ss[70].str() + "\n"; 4567 final_str = final_str + prefix + "maxTexelOffset = " + ss[71].str() + "\n"; 4568 final_str = final_str + prefix + "minTexelGatherOffset = " + ss[72].str() + "\n"; 4569 final_str = final_str + prefix + "maxTexelGatherOffset = " + ss[73].str() + "\n"; 4570 final_str = final_str + prefix + "minInterpolationOffset = " + ss[74].str() + "\n"; 4571 final_str = final_str + prefix + "maxInterpolationOffset = " + ss[75].str() + "\n"; 4572 final_str = final_str + prefix + "subPixelInterpolationOffsetBits = " + ss[76].str() + "\n"; 4573 final_str = final_str + prefix + "maxFramebufferWidth = " + ss[77].str() + "\n"; 4574 final_str = final_str + prefix + "maxFramebufferHeight = " + ss[78].str() + "\n"; 4575 final_str = final_str + prefix + "maxFramebufferLayers = " + ss[79].str() + "\n"; 4576 final_str = final_str + prefix + "framebufferColorSampleCounts = " + ss[80].str() + "\n"; 4577 final_str = final_str + prefix + "framebufferDepthSampleCounts = " + ss[81].str() + "\n"; 4578 final_str = final_str + prefix + "framebufferStencilSampleCounts = " + ss[82].str() + "\n"; 4579 final_str = final_str + prefix + "framebufferNoAttachmentsSampleCounts = " + ss[83].str() + "\n"; 4580 final_str = final_str + prefix + "maxColorAttachments = " + ss[84].str() + "\n"; 4581 final_str = final_str + prefix + "sampledImageColorSampleCounts = " + ss[85].str() + "\n"; 4582 final_str = final_str + prefix + "sampledImageIntegerSampleCounts = " + ss[86].str() + "\n"; 4583 final_str = final_str + prefix + "sampledImageDepthSampleCounts = " + ss[87].str() + "\n"; 4584 final_str = final_str + prefix + "sampledImageStencilSampleCounts = " + ss[88].str() + "\n"; 4585 final_str = final_str + prefix + "storageImageSampleCounts = " + ss[89].str() + "\n"; 4586 final_str = final_str + prefix + "maxSampleMaskWords = " + ss[90].str() + "\n"; 4587 final_str = final_str + prefix + "timestampComputeAndGraphics = " + ss[91].str() + "\n"; 4588 final_str = final_str + prefix + "timestampPeriod = " + ss[92].str() + "\n"; 4589 final_str = final_str + prefix + "maxClipDistances = " + ss[93].str() + "\n"; 4590 final_str = final_str + prefix + "maxCullDistances = " + ss[94].str() + "\n"; 4591 final_str = final_str + prefix + "maxCombinedClipAndCullDistances = " + ss[95].str() + "\n"; 4592 final_str = final_str + prefix + "discreteQueuePriorities = " + ss[96].str() + "\n"; 4593 final_str = final_str + prefix + "pointSizeRange = " + ss[97].str() + "\n"; 4594 final_str = final_str + prefix + "lineWidthRange = " + ss[98].str() + "\n"; 4595 final_str = final_str + prefix + "pointSizeGranularity = " + ss[99].str() + "\n"; 4596 final_str = final_str + prefix + "lineWidthGranularity = " + ss[100].str() + "\n"; 4597 final_str = final_str + prefix + "strictLines = " + ss[101].str() + "\n"; 4598 final_str = final_str + prefix + "standardSampleLocations = " + ss[102].str() + "\n"; 4599 final_str = final_str + prefix + "optimalBufferCopyOffsetAlignment = " + ss[103].str() + "\n"; 4600 final_str = final_str + prefix + "optimalBufferCopyRowPitchAlignment = " + ss[104].str() + "\n"; 4601 final_str = final_str + prefix + "nonCoherentAtomSize = " + ss[105].str() + "\n"; 4602 final_str = final_str + stp_strs[5] + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4603 return final_str; 4604 } 4605 // CODEGEN : file ../vk_helper.py line #907 4606 std::string vk_print_vkphysicaldevicememoryproperties(const VkPhysicalDeviceMemoryProperties* pStruct, const std::string prefix) 4607 { 4608 // CODEGEN : file ../vk_helper.py line #913 4609 using namespace StreamControl; 4610 using namespace std; 4611 string final_str; 4612 string tmp_str; 4613 string extra_indent = " " + prefix; 4614 stringstream ss[4]; 4615 string stp_strs[2]; 4616 // CODEGEN : file ../vk_helper.py line #932 4617 // CODEGEN : file ../vk_helper.py line #937 4618 // CODEGEN : file ../vk_helper.py line #939 4619 stp_strs[0] = ""; 4620 stringstream index_ss; 4621 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) { 4622 index_ss.str(""); 4623 index_ss << i; 4624 // CODEGEN : file ../vk_helper.py line #980 4625 ss[0] << "0x" << &pStruct->memoryTypes[i]; 4626 tmp_str = vk_print_vkmemorytype(&pStruct->memoryTypes[i], extra_indent); 4627 // CODEGEN : file ../vk_helper.py line #984 4628 stp_strs[0] += " " + prefix + "memoryTypes[" + index_ss.str() + "] (addr)\n" + tmp_str; 4629 // CODEGEN : file ../vk_helper.py line #1000 4630 ss[0].str(""); 4631 } 4632 // CODEGEN : file ../vk_helper.py line #932 4633 // CODEGEN : file ../vk_helper.py line #937 4634 // CODEGEN : file ../vk_helper.py line #939 4635 stp_strs[1] = ""; 4636 for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { 4637 index_ss.str(""); 4638 index_ss << i; 4639 // CODEGEN : file ../vk_helper.py line #980 4640 ss[1] << "0x" << &pStruct->memoryHeaps[i]; 4641 tmp_str = vk_print_vkmemoryheap(&pStruct->memoryHeaps[i], extra_indent); 4642 // CODEGEN : file ../vk_helper.py line #984 4643 stp_strs[1] += " " + prefix + "memoryHeaps[" + index_ss.str() + "] (addr)\n" + tmp_str; 4644 // CODEGEN : file ../vk_helper.py line #1000 4645 ss[1].str(""); 4646 } 4647 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4648 ss[0] << pStruct->memoryTypeCount; 4649 // CODEGEN : file ../vk_helper.py line #1055 4650 ss[1].str("addr"); 4651 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4652 ss[2] << pStruct->memoryHeapCount; 4653 // CODEGEN : file ../vk_helper.py line #1055 4654 ss[3].str("addr"); 4655 // CODEGEN : file ../vk_helper.py line #1113 4656 final_str = final_str + prefix + "memoryTypeCount = " + ss[0].str() + "\n"; 4657 final_str = final_str + prefix + "memoryTypes = " + ss[1].str() + "\n"; 4658 final_str = final_str + prefix + "memoryHeapCount = " + ss[2].str() + "\n"; 4659 final_str = final_str + prefix + "memoryHeaps = " + ss[3].str() + "\n"; 4660 final_str = final_str + stp_strs[1] + stp_strs[0]; 4661 return final_str; 4662 } 4663 // CODEGEN : file ../vk_helper.py line #907 4664 std::string vk_print_vkphysicaldeviceproperties(const VkPhysicalDeviceProperties* pStruct, const std::string prefix) 4665 { 4666 // CODEGEN : file ../vk_helper.py line #913 4667 using namespace StreamControl; 4668 using namespace std; 4669 string final_str; 4670 string tmp_str; 4671 string extra_indent = " " + prefix; 4672 stringstream ss[8]; 4673 string stp_strs[4]; 4674 // CODEGEN : file ../vk_helper.py line #932 4675 // CODEGEN : file ../vk_helper.py line #937 4676 // CODEGEN : file ../vk_helper.py line #939 4677 stp_strs[0] = ""; 4678 stringstream index_ss; 4679 for (uint32_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++) { 4680 index_ss.str(""); 4681 index_ss << i; 4682 // CODEGEN : file ../vk_helper.py line #990 4683 ss[0] << pStruct->deviceName[i]; 4684 stp_strs[0] += " " + prefix + "deviceName[" + index_ss.str() + "] = " + ss[0].str() + "\n"; 4685 // CODEGEN : file ../vk_helper.py line #1000 4686 ss[0].str(""); 4687 } 4688 // CODEGEN : file ../vk_helper.py line #932 4689 // CODEGEN : file ../vk_helper.py line #937 4690 // CODEGEN : file ../vk_helper.py line #939 4691 stp_strs[1] = ""; 4692 for (uint32_t i = 0; i < VK_UUID_SIZE; i++) { 4693 index_ss.str(""); 4694 index_ss << i; 4695 // CODEGEN : file ../vk_helper.py line #990 4696 ss[1] << "0x" << pStruct->pipelineCacheUUID[i]; 4697 stp_strs[1] += " " + prefix + "pipelineCacheUUID[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 4698 // CODEGEN : file ../vk_helper.py line #1000 4699 ss[1].str(""); 4700 } 4701 // CODEGEN : file ../vk_helper.py line #1038 4702 tmp_str = vk_print_vkphysicaldevicelimits(&pStruct->limits, extra_indent); 4703 ss[2] << "0x" << &pStruct->limits; 4704 stp_strs[2] = " " + prefix + "limits (addr)\n" + tmp_str; 4705 // CODEGEN : file ../vk_helper.py line #1043 4706 ss[2].str(""); 4707 // CODEGEN : file ../vk_helper.py line #1038 4708 tmp_str = vk_print_vkphysicaldevicesparseproperties(&pStruct->sparseProperties, extra_indent); 4709 ss[3] << "0x" << &pStruct->sparseProperties; 4710 stp_strs[3] = " " + prefix + "sparseProperties (addr)\n" + tmp_str; 4711 // CODEGEN : file ../vk_helper.py line #1043 4712 ss[3].str(""); 4713 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4714 ss[0] << pStruct->apiVersion; 4715 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4716 ss[1] << pStruct->driverVersion; 4717 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4718 ss[2] << "0x" << pStruct->vendorID; 4719 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 4720 ss[3] << "0x" << pStruct->deviceID; 4721 // CODEGEN : file ../vk_helper.py line #1061 4722 ss[4] << "0x" << (void*)pStruct->deviceName; 4723 // CODEGEN : file ../vk_helper.py line #1061 4724 ss[5] << "0x" << (void*)pStruct->pipelineCacheUUID; 4725 // CODEGEN : file ../vk_helper.py line #1055 4726 ss[6].str("addr"); 4727 // CODEGEN : file ../vk_helper.py line #1055 4728 ss[7].str("addr"); 4729 // CODEGEN : file ../vk_helper.py line #1113 4730 final_str = final_str + prefix + "apiVersion = " + ss[0].str() + "\n"; 4731 final_str = final_str + prefix + "driverVersion = " + ss[1].str() + "\n"; 4732 final_str = final_str + prefix + "vendorID = " + ss[2].str() + "\n"; 4733 final_str = final_str + prefix + "deviceID = " + ss[3].str() + "\n"; 4734 final_str = final_str + prefix + "deviceType = " + string_VkPhysicalDeviceType(pStruct->deviceType) + "\n"; 4735 final_str = final_str + prefix + "deviceName = " + ss[4].str() + "\n"; 4736 final_str = final_str + prefix + "pipelineCacheUUID = " + ss[5].str() + "\n"; 4737 final_str = final_str + prefix + "limits = " + ss[6].str() + "\n"; 4738 final_str = final_str + prefix + "sparseProperties = " + ss[7].str() + "\n"; 4739 final_str = final_str + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4740 return final_str; 4741 } 4742 // CODEGEN : file ../vk_helper.py line #907 4743 std::string vk_print_vkphysicaldevicesparseproperties(const VkPhysicalDeviceSparseProperties* pStruct, const std::string prefix) 4744 { 4745 // CODEGEN : file ../vk_helper.py line #913 4746 using namespace StreamControl; 4747 using namespace std; 4748 string final_str; 4749 string tmp_str; 4750 string extra_indent = " " + prefix; 4751 stringstream ss[5]; 4752 // CODEGEN : file ../vk_helper.py line #1064 4753 ss[0].str(pStruct->residencyStandard2DBlockShape ? "TRUE" : "FALSE"); 4754 // CODEGEN : file ../vk_helper.py line #1064 4755 ss[1].str(pStruct->residencyStandard2DMultisampleBlockShape ? "TRUE" : "FALSE"); 4756 // CODEGEN : file ../vk_helper.py line #1064 4757 ss[2].str(pStruct->residencyStandard3DBlockShape ? "TRUE" : "FALSE"); 4758 // CODEGEN : file ../vk_helper.py line #1064 4759 ss[3].str(pStruct->residencyAlignedMipSize ? "TRUE" : "FALSE"); 4760 // CODEGEN : file ../vk_helper.py line #1064 4761 ss[4].str(pStruct->residencyNonResidentStrict ? "TRUE" : "FALSE"); 4762 // CODEGEN : file ../vk_helper.py line #1113 4763 final_str = final_str + prefix + "residencyStandard2DBlockShape = " + ss[0].str() + "\n"; 4764 final_str = final_str + prefix + "residencyStandard2DMultisampleBlockShape = " + ss[1].str() + "\n"; 4765 final_str = final_str + prefix + "residencyStandard3DBlockShape = " + ss[2].str() + "\n"; 4766 final_str = final_str + prefix + "residencyAlignedMipSize = " + ss[3].str() + "\n"; 4767 final_str = final_str + prefix + "residencyNonResidentStrict = " + ss[4].str() + "\n"; 4768 return final_str; 4769 } 4770 // CODEGEN : file ../vk_helper.py line #907 4771 std::string vk_print_vkpipelinecachecreateinfo(const VkPipelineCacheCreateInfo* pStruct, const std::string prefix) 4772 { 4773 // CODEGEN : file ../vk_helper.py line #913 4774 using namespace StreamControl; 4775 using namespace std; 4776 string final_str; 4777 string tmp_str; 4778 string extra_indent = " " + prefix; 4779 stringstream ss[4]; 4780 string stp_strs[1]; 4781 // CODEGEN : file ../vk_helper.py line #1012 4782 if (pStruct->pNext) { 4783 // CODEGEN : file ../vk_helper.py line #1016 4784 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4785 ss[0] << "0x" << &pStruct->pNext; 4786 // CODEGEN : file ../vk_helper.py line #1028 4787 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4788 ss[0].str(""); 4789 } 4790 else 4791 stp_strs[0] = ""; 4792 // CODEGEN : file ../vk_helper.py line #1070 4793 if (StreamControl::writeAddress) 4794 ss[0] << "0x" << pStruct->pNext; 4795 else 4796 ss[0].str("address"); 4797 // CODEGEN : file ../vk_helper.py line #1086 4798 ss[1] << "0x" << pStruct->flags; 4799 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4800 ss[2] << pStruct->initialDataSize; 4801 // CODEGEN : file ../vk_helper.py line #1070 4802 if (StreamControl::writeAddress) 4803 ss[3] << "0x" << pStruct->pInitialData; 4804 else 4805 ss[3].str("address"); 4806 // CODEGEN : file ../vk_helper.py line #1113 4807 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 4808 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 4809 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 4810 final_str = final_str + prefix + "initialDataSize = " + ss[2].str() + "\n"; 4811 final_str = final_str + prefix + "pInitialData = " + ss[3].str() + "\n"; 4812 final_str = final_str + stp_strs[0]; 4813 return final_str; 4814 } 4815 // CODEGEN : file ../vk_helper.py line #907 4816 std::string vk_print_vkpipelinecolorblendattachmentstate(const VkPipelineColorBlendAttachmentState* pStruct, const std::string prefix) 4817 { 4818 // CODEGEN : file ../vk_helper.py line #913 4819 using namespace StreamControl; 4820 using namespace std; 4821 string final_str; 4822 string tmp_str; 4823 string extra_indent = " " + prefix; 4824 stringstream ss[2]; 4825 // CODEGEN : file ../vk_helper.py line #1064 4826 ss[0].str(pStruct->blendEnable ? "TRUE" : "FALSE"); 4827 // CODEGEN : file ../vk_helper.py line #1086 4828 ss[1] << "0x" << pStruct->colorWriteMask; 4829 // CODEGEN : file ../vk_helper.py line #1113 4830 final_str = final_str + prefix + "blendEnable = " + ss[0].str() + "\n"; 4831 final_str = final_str + prefix + "srcColorBlendFactor = " + string_VkBlendFactor(pStruct->srcColorBlendFactor) + "\n"; 4832 final_str = final_str + prefix + "dstColorBlendFactor = " + string_VkBlendFactor(pStruct->dstColorBlendFactor) + "\n"; 4833 final_str = final_str + prefix + "colorBlendOp = " + string_VkBlendOp(pStruct->colorBlendOp) + "\n"; 4834 final_str = final_str + prefix + "srcAlphaBlendFactor = " + string_VkBlendFactor(pStruct->srcAlphaBlendFactor) + "\n"; 4835 final_str = final_str + prefix + "dstAlphaBlendFactor = " + string_VkBlendFactor(pStruct->dstAlphaBlendFactor) + "\n"; 4836 final_str = final_str + prefix + "alphaBlendOp = " + string_VkBlendOp(pStruct->alphaBlendOp) + "\n"; 4837 final_str = final_str + prefix + "colorWriteMask = " + ss[1].str() + "\n"; 4838 return final_str; 4839 } 4840 // CODEGEN : file ../vk_helper.py line #907 4841 std::string vk_print_vkpipelinecolorblendstatecreateinfo(const VkPipelineColorBlendStateCreateInfo* pStruct, const std::string prefix) 4842 { 4843 // CODEGEN : file ../vk_helper.py line #913 4844 using namespace StreamControl; 4845 using namespace std; 4846 string final_str; 4847 string tmp_str; 4848 string extra_indent = " " + prefix; 4849 stringstream ss[6]; 4850 string stp_strs[3]; 4851 // CODEGEN : file ../vk_helper.py line #1012 4852 if (pStruct->pNext) { 4853 // CODEGEN : file ../vk_helper.py line #1016 4854 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4855 ss[0] << "0x" << &pStruct->pNext; 4856 // CODEGEN : file ../vk_helper.py line #1028 4857 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4858 ss[0].str(""); 4859 } 4860 else 4861 stp_strs[0] = ""; 4862 // CODEGEN : file ../vk_helper.py line #932 4863 // CODEGEN : file ../vk_helper.py line #934 4864 // CODEGEN : file ../vk_helper.py line #939 4865 stp_strs[1] = ""; 4866 stringstream index_ss; 4867 if (pStruct->pAttachments) { 4868 for (uint32_t i = 0; i < pStruct->attachmentCount; i++) { 4869 index_ss.str(""); 4870 index_ss << i; 4871 // CODEGEN : file ../vk_helper.py line #980 4872 ss[1] << "0x" << &pStruct->pAttachments[i]; 4873 tmp_str = vk_print_vkpipelinecolorblendattachmentstate(&pStruct->pAttachments[i], extra_indent); 4874 // CODEGEN : file ../vk_helper.py line #984 4875 stp_strs[1] += " " + prefix + "pAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 4876 // CODEGEN : file ../vk_helper.py line #1000 4877 ss[1].str(""); 4878 } 4879 } 4880 // CODEGEN : file ../vk_helper.py line #932 4881 // CODEGEN : file ../vk_helper.py line #937 4882 // CODEGEN : file ../vk_helper.py line #939 4883 stp_strs[2] = ""; 4884 for (uint32_t i = 0; i < 4; i++) { 4885 index_ss.str(""); 4886 index_ss << i; 4887 // CODEGEN : file ../vk_helper.py line #990 4888 ss[2] << pStruct->blendConstants[i]; 4889 stp_strs[2] += " " + prefix + "blendConstants[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 4890 // CODEGEN : file ../vk_helper.py line #1000 4891 ss[2].str(""); 4892 } 4893 // CODEGEN : file ../vk_helper.py line #1070 4894 if (StreamControl::writeAddress) 4895 ss[0] << "0x" << pStruct->pNext; 4896 else 4897 ss[0].str("address"); 4898 // CODEGEN : file ../vk_helper.py line #1086 4899 ss[1] << "0x" << pStruct->flags; 4900 // CODEGEN : file ../vk_helper.py line #1064 4901 ss[2].str(pStruct->logicOpEnable ? "TRUE" : "FALSE"); 4902 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4903 ss[3] << pStruct->attachmentCount; 4904 // CODEGEN : file ../vk_helper.py line #1061 4905 ss[4] << "0x" << (void*)pStruct->pAttachments; 4906 // CODEGEN : file ../vk_helper.py line #1061 4907 ss[5] << "0x" << (void*)pStruct->blendConstants; 4908 // CODEGEN : file ../vk_helper.py line #1113 4909 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 4910 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 4911 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 4912 final_str = final_str + prefix + "logicOpEnable = " + ss[2].str() + "\n"; 4913 final_str = final_str + prefix + "logicOp = " + string_VkLogicOp(pStruct->logicOp) + "\n"; 4914 final_str = final_str + prefix + "attachmentCount = " + ss[3].str() + "\n"; 4915 final_str = final_str + prefix + "pAttachments = " + ss[4].str() + "\n"; 4916 final_str = final_str + prefix + "blendConstants = " + ss[5].str() + "\n"; 4917 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4918 return final_str; 4919 } 4920 // CODEGEN : file ../vk_helper.py line #907 4921 std::string vk_print_vkpipelinedepthstencilstatecreateinfo(const VkPipelineDepthStencilStateCreateInfo* pStruct, const std::string prefix) 4922 { 4923 // CODEGEN : file ../vk_helper.py line #913 4924 using namespace StreamControl; 4925 using namespace std; 4926 string final_str; 4927 string tmp_str; 4928 string extra_indent = " " + prefix; 4929 stringstream ss[10]; 4930 string stp_strs[3]; 4931 // CODEGEN : file ../vk_helper.py line #1012 4932 if (pStruct->pNext) { 4933 // CODEGEN : file ../vk_helper.py line #1016 4934 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 4935 ss[0] << "0x" << &pStruct->pNext; 4936 // CODEGEN : file ../vk_helper.py line #1028 4937 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 4938 ss[0].str(""); 4939 } 4940 else 4941 stp_strs[0] = ""; 4942 // CODEGEN : file ../vk_helper.py line #1038 4943 tmp_str = vk_print_vkstencilopstate(&pStruct->front, extra_indent); 4944 ss[1] << "0x" << &pStruct->front; 4945 stp_strs[1] = " " + prefix + "front (addr)\n" + tmp_str; 4946 // CODEGEN : file ../vk_helper.py line #1043 4947 ss[1].str(""); 4948 // CODEGEN : file ../vk_helper.py line #1038 4949 tmp_str = vk_print_vkstencilopstate(&pStruct->back, extra_indent); 4950 ss[2] << "0x" << &pStruct->back; 4951 stp_strs[2] = " " + prefix + "back (addr)\n" + tmp_str; 4952 // CODEGEN : file ../vk_helper.py line #1043 4953 ss[2].str(""); 4954 // CODEGEN : file ../vk_helper.py line #1070 4955 if (StreamControl::writeAddress) 4956 ss[0] << "0x" << pStruct->pNext; 4957 else 4958 ss[0].str("address"); 4959 // CODEGEN : file ../vk_helper.py line #1086 4960 ss[1] << "0x" << pStruct->flags; 4961 // CODEGEN : file ../vk_helper.py line #1064 4962 ss[2].str(pStruct->depthTestEnable ? "TRUE" : "FALSE"); 4963 // CODEGEN : file ../vk_helper.py line #1064 4964 ss[3].str(pStruct->depthWriteEnable ? "TRUE" : "FALSE"); 4965 // CODEGEN : file ../vk_helper.py line #1064 4966 ss[4].str(pStruct->depthBoundsTestEnable ? "TRUE" : "FALSE"); 4967 // CODEGEN : file ../vk_helper.py line #1064 4968 ss[5].str(pStruct->stencilTestEnable ? "TRUE" : "FALSE"); 4969 // CODEGEN : file ../vk_helper.py line #1055 4970 ss[6].str("addr"); 4971 // CODEGEN : file ../vk_helper.py line #1055 4972 ss[7].str("addr"); 4973 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4974 ss[8] << pStruct->minDepthBounds; 4975 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 4976 ss[9] << pStruct->maxDepthBounds; 4977 // CODEGEN : file ../vk_helper.py line #1113 4978 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 4979 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 4980 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 4981 final_str = final_str + prefix + "depthTestEnable = " + ss[2].str() + "\n"; 4982 final_str = final_str + prefix + "depthWriteEnable = " + ss[3].str() + "\n"; 4983 final_str = final_str + prefix + "depthCompareOp = " + string_VkCompareOp(pStruct->depthCompareOp) + "\n"; 4984 final_str = final_str + prefix + "depthBoundsTestEnable = " + ss[4].str() + "\n"; 4985 final_str = final_str + prefix + "stencilTestEnable = " + ss[5].str() + "\n"; 4986 final_str = final_str + prefix + "front = " + ss[6].str() + "\n"; 4987 final_str = final_str + prefix + "back = " + ss[7].str() + "\n"; 4988 final_str = final_str + prefix + "minDepthBounds = " + ss[8].str() + "\n"; 4989 final_str = final_str + prefix + "maxDepthBounds = " + ss[9].str() + "\n"; 4990 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 4991 return final_str; 4992 } 4993 // CODEGEN : file ../vk_helper.py line #907 4994 std::string vk_print_vkpipelinedynamicstatecreateinfo(const VkPipelineDynamicStateCreateInfo* pStruct, const std::string prefix) 4995 { 4996 // CODEGEN : file ../vk_helper.py line #913 4997 using namespace StreamControl; 4998 using namespace std; 4999 string final_str; 5000 string tmp_str; 5001 string extra_indent = " " + prefix; 5002 stringstream ss[4]; 5003 string stp_strs[2]; 5004 // CODEGEN : file ../vk_helper.py line #1012 5005 if (pStruct->pNext) { 5006 // CODEGEN : file ../vk_helper.py line #1016 5007 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5008 ss[0] << "0x" << &pStruct->pNext; 5009 // CODEGEN : file ../vk_helper.py line #1028 5010 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5011 ss[0].str(""); 5012 } 5013 else 5014 stp_strs[0] = ""; 5015 // CODEGEN : file ../vk_helper.py line #932 5016 // CODEGEN : file ../vk_helper.py line #934 5017 // CODEGEN : file ../vk_helper.py line #939 5018 stp_strs[1] = ""; 5019 stringstream index_ss; 5020 if (pStruct->pDynamicStates) { 5021 for (uint32_t i = 0; i < pStruct->dynamicStateCount; i++) { 5022 index_ss.str(""); 5023 index_ss << i; 5024 // CODEGEN : file ../vk_helper.py line #974 5025 ss[1] << string_VkDynamicState(pStruct->pDynamicStates[i]); 5026 stp_strs[1] += " " + prefix + "pDynamicStates[" + index_ss.str() + "] = " + ss[1].str() + "\n"; 5027 // CODEGEN : file ../vk_helper.py line #1000 5028 ss[1].str(""); 5029 } 5030 } 5031 // CODEGEN : file ../vk_helper.py line #1070 5032 if (StreamControl::writeAddress) 5033 ss[0] << "0x" << pStruct->pNext; 5034 else 5035 ss[0].str("address"); 5036 // CODEGEN : file ../vk_helper.py line #1086 5037 ss[1] << "0x" << pStruct->flags; 5038 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5039 ss[2] << pStruct->dynamicStateCount; 5040 // CODEGEN : file ../vk_helper.py line #1100 5041 if (pStruct->pDynamicStates) 5042 ss[3] << "0x" << pStruct->pDynamicStates << " (See individual array values below)"; 5043 else 5044 ss[3].str("NULL"); 5045 // CODEGEN : file ../vk_helper.py line #1113 5046 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5047 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5048 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5049 final_str = final_str + prefix + "dynamicStateCount = " + ss[2].str() + "\n"; 5050 final_str = final_str + prefix + "pDynamicStates = " + ss[3].str() + "\n"; 5051 final_str = final_str + stp_strs[1] + stp_strs[0]; 5052 return final_str; 5053 } 5054 // CODEGEN : file ../vk_helper.py line #907 5055 std::string vk_print_vkpipelineinputassemblystatecreateinfo(const VkPipelineInputAssemblyStateCreateInfo* pStruct, const std::string prefix) 5056 { 5057 // CODEGEN : file ../vk_helper.py line #913 5058 using namespace StreamControl; 5059 using namespace std; 5060 string final_str; 5061 string tmp_str; 5062 string extra_indent = " " + prefix; 5063 stringstream ss[3]; 5064 string stp_strs[1]; 5065 // CODEGEN : file ../vk_helper.py line #1012 5066 if (pStruct->pNext) { 5067 // CODEGEN : file ../vk_helper.py line #1016 5068 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5069 ss[0] << "0x" << &pStruct->pNext; 5070 // CODEGEN : file ../vk_helper.py line #1028 5071 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5072 ss[0].str(""); 5073 } 5074 else 5075 stp_strs[0] = ""; 5076 // CODEGEN : file ../vk_helper.py line #1070 5077 if (StreamControl::writeAddress) 5078 ss[0] << "0x" << pStruct->pNext; 5079 else 5080 ss[0].str("address"); 5081 // CODEGEN : file ../vk_helper.py line #1086 5082 ss[1] << "0x" << pStruct->flags; 5083 // CODEGEN : file ../vk_helper.py line #1064 5084 ss[2].str(pStruct->primitiveRestartEnable ? "TRUE" : "FALSE"); 5085 // CODEGEN : file ../vk_helper.py line #1113 5086 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5087 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5088 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5089 final_str = final_str + prefix + "topology = " + string_VkPrimitiveTopology(pStruct->topology) + "\n"; 5090 final_str = final_str + prefix + "primitiveRestartEnable = " + ss[2].str() + "\n"; 5091 final_str = final_str + stp_strs[0]; 5092 return final_str; 5093 } 5094 // CODEGEN : file ../vk_helper.py line #907 5095 std::string vk_print_vkpipelinelayoutcreateinfo(const VkPipelineLayoutCreateInfo* pStruct, const std::string prefix) 5096 { 5097 // CODEGEN : file ../vk_helper.py line #913 5098 using namespace StreamControl; 5099 using namespace std; 5100 string final_str; 5101 string tmp_str; 5102 string extra_indent = " " + prefix; 5103 stringstream ss[6]; 5104 string stp_strs[3]; 5105 // CODEGEN : file ../vk_helper.py line #1012 5106 if (pStruct->pNext) { 5107 // CODEGEN : file ../vk_helper.py line #1016 5108 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5109 ss[0] << "0x" << &pStruct->pNext; 5110 // CODEGEN : file ../vk_helper.py line #1028 5111 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5112 ss[0].str(""); 5113 } 5114 else 5115 stp_strs[0] = ""; 5116 // CODEGEN : file ../vk_helper.py line #932 5117 // CODEGEN : file ../vk_helper.py line #934 5118 // CODEGEN : file ../vk_helper.py line #939 5119 stp_strs[1] = ""; 5120 stringstream index_ss; 5121 if (pStruct->pSetLayouts) { 5122 for (uint32_t i = 0; i < pStruct->setLayoutCount; i++) { 5123 index_ss.str(""); 5124 index_ss << i; 5125 // CODEGEN : file ../vk_helper.py line #990 5126 ss[1] << "0x" << pStruct->pSetLayouts[i]; 5127 stp_strs[1] += " " + prefix + "pSetLayouts[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 5128 // CODEGEN : file ../vk_helper.py line #1000 5129 ss[1].str(""); 5130 } 5131 } 5132 // CODEGEN : file ../vk_helper.py line #932 5133 // CODEGEN : file ../vk_helper.py line #934 5134 // CODEGEN : file ../vk_helper.py line #939 5135 stp_strs[2] = ""; 5136 if (pStruct->pPushConstantRanges) { 5137 for (uint32_t i = 0; i < pStruct->pushConstantRangeCount; i++) { 5138 index_ss.str(""); 5139 index_ss << i; 5140 // CODEGEN : file ../vk_helper.py line #980 5141 ss[2] << "0x" << &pStruct->pPushConstantRanges[i]; 5142 tmp_str = vk_print_vkpushconstantrange(&pStruct->pPushConstantRanges[i], extra_indent); 5143 // CODEGEN : file ../vk_helper.py line #984 5144 stp_strs[2] += " " + prefix + "pPushConstantRanges[" + index_ss.str() + "] (addr)\n" + tmp_str; 5145 // CODEGEN : file ../vk_helper.py line #1000 5146 ss[2].str(""); 5147 } 5148 } 5149 // CODEGEN : file ../vk_helper.py line #1070 5150 if (StreamControl::writeAddress) 5151 ss[0] << "0x" << pStruct->pNext; 5152 else 5153 ss[0].str("address"); 5154 // CODEGEN : file ../vk_helper.py line #1086 5155 ss[1] << "0x" << pStruct->flags; 5156 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5157 ss[2] << pStruct->setLayoutCount; 5158 // CODEGEN : file ../vk_helper.py line #1061 5159 ss[3] << "0x" << (void*)pStruct->pSetLayouts; 5160 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5161 ss[4] << pStruct->pushConstantRangeCount; 5162 // CODEGEN : file ../vk_helper.py line #1061 5163 ss[5] << "0x" << (void*)pStruct->pPushConstantRanges; 5164 // CODEGEN : file ../vk_helper.py line #1113 5165 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5166 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5167 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5168 final_str = final_str + prefix + "setLayoutCount = " + ss[2].str() + "\n"; 5169 final_str = final_str + prefix + "pSetLayouts = " + ss[3].str() + "\n"; 5170 final_str = final_str + prefix + "pushConstantRangeCount = " + ss[4].str() + "\n"; 5171 final_str = final_str + prefix + "pPushConstantRanges = " + ss[5].str() + "\n"; 5172 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5173 return final_str; 5174 } 5175 // CODEGEN : file ../vk_helper.py line #907 5176 std::string vk_print_vkpipelinemultisamplestatecreateinfo(const VkPipelineMultisampleStateCreateInfo* pStruct, const std::string prefix) 5177 { 5178 // CODEGEN : file ../vk_helper.py line #913 5179 using namespace StreamControl; 5180 using namespace std; 5181 string final_str; 5182 string tmp_str; 5183 string extra_indent = " " + prefix; 5184 stringstream ss[7]; 5185 string stp_strs[1]; 5186 // CODEGEN : file ../vk_helper.py line #1012 5187 if (pStruct->pNext) { 5188 // CODEGEN : file ../vk_helper.py line #1016 5189 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5190 ss[0] << "0x" << &pStruct->pNext; 5191 // CODEGEN : file ../vk_helper.py line #1028 5192 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5193 ss[0].str(""); 5194 } 5195 else 5196 stp_strs[0] = ""; 5197 // CODEGEN : file ../vk_helper.py line #1070 5198 if (StreamControl::writeAddress) 5199 ss[0] << "0x" << pStruct->pNext; 5200 else 5201 ss[0].str("address"); 5202 // CODEGEN : file ../vk_helper.py line #1086 5203 ss[1] << "0x" << pStruct->flags; 5204 // CODEGEN : file ../vk_helper.py line #1064 5205 ss[2].str(pStruct->sampleShadingEnable ? "TRUE" : "FALSE"); 5206 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5207 ss[3] << pStruct->minSampleShading; 5208 // CODEGEN : file ../vk_helper.py line #1086 5209 ss[4] << "0x" << pStruct->pSampleMask; 5210 // CODEGEN : file ../vk_helper.py line #1064 5211 ss[5].str(pStruct->alphaToCoverageEnable ? "TRUE" : "FALSE"); 5212 // CODEGEN : file ../vk_helper.py line #1064 5213 ss[6].str(pStruct->alphaToOneEnable ? "TRUE" : "FALSE"); 5214 // CODEGEN : file ../vk_helper.py line #1113 5215 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5216 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5217 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5218 final_str = final_str + prefix + "rasterizationSamples = " + string_VkSampleCountFlagBits(pStruct->rasterizationSamples) + "\n"; 5219 final_str = final_str + prefix + "sampleShadingEnable = " + ss[2].str() + "\n"; 5220 final_str = final_str + prefix + "minSampleShading = " + ss[3].str() + "\n"; 5221 final_str = final_str + prefix + "pSampleMask = " + ss[4].str() + "\n"; 5222 final_str = final_str + prefix + "alphaToCoverageEnable = " + ss[5].str() + "\n"; 5223 final_str = final_str + prefix + "alphaToOneEnable = " + ss[6].str() + "\n"; 5224 final_str = final_str + stp_strs[0]; 5225 return final_str; 5226 } 5227 // CODEGEN : file ../vk_helper.py line #907 5228 std::string vk_print_vkpipelinerasterizationstatecreateinfo(const VkPipelineRasterizationStateCreateInfo* pStruct, const std::string prefix) 5229 { 5230 // CODEGEN : file ../vk_helper.py line #913 5231 using namespace StreamControl; 5232 using namespace std; 5233 string final_str; 5234 string tmp_str; 5235 string extra_indent = " " + prefix; 5236 stringstream ss[10]; 5237 string stp_strs[1]; 5238 // CODEGEN : file ../vk_helper.py line #1012 5239 if (pStruct->pNext) { 5240 // CODEGEN : file ../vk_helper.py line #1016 5241 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5242 ss[0] << "0x" << &pStruct->pNext; 5243 // CODEGEN : file ../vk_helper.py line #1028 5244 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5245 ss[0].str(""); 5246 } 5247 else 5248 stp_strs[0] = ""; 5249 // CODEGEN : file ../vk_helper.py line #1070 5250 if (StreamControl::writeAddress) 5251 ss[0] << "0x" << pStruct->pNext; 5252 else 5253 ss[0].str("address"); 5254 // CODEGEN : file ../vk_helper.py line #1086 5255 ss[1] << "0x" << pStruct->flags; 5256 // CODEGEN : file ../vk_helper.py line #1064 5257 ss[2].str(pStruct->depthClampEnable ? "TRUE" : "FALSE"); 5258 // CODEGEN : file ../vk_helper.py line #1064 5259 ss[3].str(pStruct->rasterizerDiscardEnable ? "TRUE" : "FALSE"); 5260 // CODEGEN : file ../vk_helper.py line #1086 5261 ss[4] << "0x" << pStruct->cullMode; 5262 // CODEGEN : file ../vk_helper.py line #1064 5263 ss[5].str(pStruct->depthBiasEnable ? "TRUE" : "FALSE"); 5264 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5265 ss[6] << pStruct->depthBiasConstantFactor; 5266 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5267 ss[7] << pStruct->depthBiasClamp; 5268 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5269 ss[8] << pStruct->depthBiasSlopeFactor; 5270 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5271 ss[9] << pStruct->lineWidth; 5272 // CODEGEN : file ../vk_helper.py line #1113 5273 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5274 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5275 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5276 final_str = final_str + prefix + "depthClampEnable = " + ss[2].str() + "\n"; 5277 final_str = final_str + prefix + "rasterizerDiscardEnable = " + ss[3].str() + "\n"; 5278 final_str = final_str + prefix + "polygonMode = " + string_VkPolygonMode(pStruct->polygonMode) + "\n"; 5279 final_str = final_str + prefix + "cullMode = " + ss[4].str() + "\n"; 5280 final_str = final_str + prefix + "frontFace = " + string_VkFrontFace(pStruct->frontFace) + "\n"; 5281 final_str = final_str + prefix + "depthBiasEnable = " + ss[5].str() + "\n"; 5282 final_str = final_str + prefix + "depthBiasConstantFactor = " + ss[6].str() + "\n"; 5283 final_str = final_str + prefix + "depthBiasClamp = " + ss[7].str() + "\n"; 5284 final_str = final_str + prefix + "depthBiasSlopeFactor = " + ss[8].str() + "\n"; 5285 final_str = final_str + prefix + "lineWidth = " + ss[9].str() + "\n"; 5286 final_str = final_str + stp_strs[0]; 5287 return final_str; 5288 } 5289 // CODEGEN : file ../vk_helper.py line #907 5290 std::string vk_print_vkpipelinerasterizationstaterasterizationorderamd(const VkPipelineRasterizationStateRasterizationOrderAMD* pStruct, const std::string prefix) 5291 { 5292 // CODEGEN : file ../vk_helper.py line #913 5293 using namespace StreamControl; 5294 using namespace std; 5295 string final_str; 5296 string tmp_str; 5297 string extra_indent = " " + prefix; 5298 stringstream ss[1]; 5299 string stp_strs[1]; 5300 // CODEGEN : file ../vk_helper.py line #1012 5301 if (pStruct->pNext) { 5302 // CODEGEN : file ../vk_helper.py line #1016 5303 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5304 ss[0] << "0x" << &pStruct->pNext; 5305 // CODEGEN : file ../vk_helper.py line #1028 5306 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5307 ss[0].str(""); 5308 } 5309 else 5310 stp_strs[0] = ""; 5311 // CODEGEN : file ../vk_helper.py line #1070 5312 if (StreamControl::writeAddress) 5313 ss[0] << "0x" << pStruct->pNext; 5314 else 5315 ss[0].str("address"); 5316 // CODEGEN : file ../vk_helper.py line #1113 5317 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5318 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5319 final_str = final_str + prefix + "rasterizationOrder = " + string_VkRasterizationOrderAMD(pStruct->rasterizationOrder) + "\n"; 5320 final_str = final_str + stp_strs[0]; 5321 return final_str; 5322 } 5323 // CODEGEN : file ../vk_helper.py line #907 5324 std::string vk_print_vkpipelineshaderstagecreateinfo(const VkPipelineShaderStageCreateInfo* pStruct, const std::string prefix) 5325 { 5326 // CODEGEN : file ../vk_helper.py line #913 5327 using namespace StreamControl; 5328 using namespace std; 5329 string final_str; 5330 string tmp_str; 5331 string extra_indent = " " + prefix; 5332 stringstream ss[5]; 5333 string stp_strs[2]; 5334 // CODEGEN : file ../vk_helper.py line #1012 5335 if (pStruct->pNext) { 5336 // CODEGEN : file ../vk_helper.py line #1016 5337 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5338 ss[0] << "0x" << &pStruct->pNext; 5339 // CODEGEN : file ../vk_helper.py line #1028 5340 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5341 ss[0].str(""); 5342 } 5343 else 5344 stp_strs[0] = ""; 5345 // CODEGEN : file ../vk_helper.py line #1012 5346 if (pStruct->pSpecializationInfo) { 5347 // CODEGEN : file ../vk_helper.py line #1024 5348 tmp_str = vk_print_vkspecializationinfo(pStruct->pSpecializationInfo, extra_indent); 5349 ss[1] << "0x" << &pStruct->pSpecializationInfo; 5350 // CODEGEN : file ../vk_helper.py line #1028 5351 stp_strs[1] = " " + prefix + "pSpecializationInfo (addr)\n" + tmp_str; 5352 ss[1].str(""); 5353 } 5354 else 5355 stp_strs[1] = ""; 5356 // CODEGEN : file ../vk_helper.py line #1070 5357 if (StreamControl::writeAddress) 5358 ss[0] << "0x" << pStruct->pNext; 5359 else 5360 ss[0].str("address"); 5361 // CODEGEN : file ../vk_helper.py line #1086 5362 ss[1] << "0x" << pStruct->flags; 5363 // CODEGEN : file ../vk_helper.py line #1086 5364 ss[2] << "0x" << pStruct->module; 5365 // CODEGEN : file ../vk_helper.py line #1076 5366 if (pStruct->pName != NULL) { 5367 ss[3] << pStruct->pName; 5368 } else { 5369 ss[3] << ""; 5370 } 5371 // CODEGEN : file ../vk_helper.py line #1086 5372 ss[4] << "0x" << pStruct->pSpecializationInfo; 5373 // CODEGEN : file ../vk_helper.py line #1113 5374 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5375 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5376 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5377 final_str = final_str + prefix + "stage = " + string_VkShaderStageFlagBits(pStruct->stage) + "\n"; 5378 final_str = final_str + prefix + "module = " + ss[2].str() + "\n"; 5379 final_str = final_str + prefix + "pName = " + ss[3].str() + "\n"; 5380 final_str = final_str + prefix + "pSpecializationInfo = " + ss[4].str() + "\n"; 5381 final_str = final_str + stp_strs[1] + stp_strs[0]; 5382 return final_str; 5383 } 5384 // CODEGEN : file ../vk_helper.py line #907 5385 std::string vk_print_vkpipelinetessellationstatecreateinfo(const VkPipelineTessellationStateCreateInfo* pStruct, const std::string prefix) 5386 { 5387 // CODEGEN : file ../vk_helper.py line #913 5388 using namespace StreamControl; 5389 using namespace std; 5390 string final_str; 5391 string tmp_str; 5392 string extra_indent = " " + prefix; 5393 stringstream ss[3]; 5394 string stp_strs[1]; 5395 // CODEGEN : file ../vk_helper.py line #1012 5396 if (pStruct->pNext) { 5397 // CODEGEN : file ../vk_helper.py line #1016 5398 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5399 ss[0] << "0x" << &pStruct->pNext; 5400 // CODEGEN : file ../vk_helper.py line #1028 5401 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5402 ss[0].str(""); 5403 } 5404 else 5405 stp_strs[0] = ""; 5406 // CODEGEN : file ../vk_helper.py line #1070 5407 if (StreamControl::writeAddress) 5408 ss[0] << "0x" << pStruct->pNext; 5409 else 5410 ss[0].str("address"); 5411 // CODEGEN : file ../vk_helper.py line #1086 5412 ss[1] << "0x" << pStruct->flags; 5413 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5414 ss[2] << pStruct->patchControlPoints; 5415 // CODEGEN : file ../vk_helper.py line #1113 5416 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5417 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5418 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5419 final_str = final_str + prefix + "patchControlPoints = " + ss[2].str() + "\n"; 5420 final_str = final_str + stp_strs[0]; 5421 return final_str; 5422 } 5423 // CODEGEN : file ../vk_helper.py line #907 5424 std::string vk_print_vkpipelinevertexinputstatecreateinfo(const VkPipelineVertexInputStateCreateInfo* pStruct, const std::string prefix) 5425 { 5426 // CODEGEN : file ../vk_helper.py line #913 5427 using namespace StreamControl; 5428 using namespace std; 5429 string final_str; 5430 string tmp_str; 5431 string extra_indent = " " + prefix; 5432 stringstream ss[6]; 5433 string stp_strs[3]; 5434 // CODEGEN : file ../vk_helper.py line #1012 5435 if (pStruct->pNext) { 5436 // CODEGEN : file ../vk_helper.py line #1016 5437 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5438 ss[0] << "0x" << &pStruct->pNext; 5439 // CODEGEN : file ../vk_helper.py line #1028 5440 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5441 ss[0].str(""); 5442 } 5443 else 5444 stp_strs[0] = ""; 5445 // CODEGEN : file ../vk_helper.py line #932 5446 // CODEGEN : file ../vk_helper.py line #934 5447 // CODEGEN : file ../vk_helper.py line #939 5448 stp_strs[1] = ""; 5449 stringstream index_ss; 5450 if (pStruct->pVertexBindingDescriptions) { 5451 for (uint32_t i = 0; i < pStruct->vertexBindingDescriptionCount; i++) { 5452 index_ss.str(""); 5453 index_ss << i; 5454 // CODEGEN : file ../vk_helper.py line #980 5455 ss[1] << "0x" << &pStruct->pVertexBindingDescriptions[i]; 5456 tmp_str = vk_print_vkvertexinputbindingdescription(&pStruct->pVertexBindingDescriptions[i], extra_indent); 5457 // CODEGEN : file ../vk_helper.py line #984 5458 stp_strs[1] += " " + prefix + "pVertexBindingDescriptions[" + index_ss.str() + "] (addr)\n" + tmp_str; 5459 // CODEGEN : file ../vk_helper.py line #1000 5460 ss[1].str(""); 5461 } 5462 } 5463 // CODEGEN : file ../vk_helper.py line #932 5464 // CODEGEN : file ../vk_helper.py line #934 5465 // CODEGEN : file ../vk_helper.py line #939 5466 stp_strs[2] = ""; 5467 if (pStruct->pVertexAttributeDescriptions) { 5468 for (uint32_t i = 0; i < pStruct->vertexAttributeDescriptionCount; i++) { 5469 index_ss.str(""); 5470 index_ss << i; 5471 // CODEGEN : file ../vk_helper.py line #980 5472 ss[2] << "0x" << &pStruct->pVertexAttributeDescriptions[i]; 5473 tmp_str = vk_print_vkvertexinputattributedescription(&pStruct->pVertexAttributeDescriptions[i], extra_indent); 5474 // CODEGEN : file ../vk_helper.py line #984 5475 stp_strs[2] += " " + prefix + "pVertexAttributeDescriptions[" + index_ss.str() + "] (addr)\n" + tmp_str; 5476 // CODEGEN : file ../vk_helper.py line #1000 5477 ss[2].str(""); 5478 } 5479 } 5480 // CODEGEN : file ../vk_helper.py line #1070 5481 if (StreamControl::writeAddress) 5482 ss[0] << "0x" << pStruct->pNext; 5483 else 5484 ss[0].str("address"); 5485 // CODEGEN : file ../vk_helper.py line #1086 5486 ss[1] << "0x" << pStruct->flags; 5487 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5488 ss[2] << pStruct->vertexBindingDescriptionCount; 5489 // CODEGEN : file ../vk_helper.py line #1061 5490 ss[3] << "0x" << (void*)pStruct->pVertexBindingDescriptions; 5491 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5492 ss[4] << pStruct->vertexAttributeDescriptionCount; 5493 // CODEGEN : file ../vk_helper.py line #1061 5494 ss[5] << "0x" << (void*)pStruct->pVertexAttributeDescriptions; 5495 // CODEGEN : file ../vk_helper.py line #1113 5496 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5497 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5498 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5499 final_str = final_str + prefix + "vertexBindingDescriptionCount = " + ss[2].str() + "\n"; 5500 final_str = final_str + prefix + "pVertexBindingDescriptions = " + ss[3].str() + "\n"; 5501 final_str = final_str + prefix + "vertexAttributeDescriptionCount = " + ss[4].str() + "\n"; 5502 final_str = final_str + prefix + "pVertexAttributeDescriptions = " + ss[5].str() + "\n"; 5503 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5504 return final_str; 5505 } 5506 // CODEGEN : file ../vk_helper.py line #907 5507 std::string vk_print_vkpipelineviewportstatecreateinfo(const VkPipelineViewportStateCreateInfo* pStruct, const std::string prefix) 5508 { 5509 // CODEGEN : file ../vk_helper.py line #913 5510 using namespace StreamControl; 5511 using namespace std; 5512 string final_str; 5513 string tmp_str; 5514 string extra_indent = " " + prefix; 5515 stringstream ss[6]; 5516 string stp_strs[3]; 5517 // CODEGEN : file ../vk_helper.py line #1012 5518 if (pStruct->pNext) { 5519 // CODEGEN : file ../vk_helper.py line #1016 5520 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5521 ss[0] << "0x" << &pStruct->pNext; 5522 // CODEGEN : file ../vk_helper.py line #1028 5523 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5524 ss[0].str(""); 5525 } 5526 else 5527 stp_strs[0] = ""; 5528 // CODEGEN : file ../vk_helper.py line #932 5529 // CODEGEN : file ../vk_helper.py line #934 5530 // CODEGEN : file ../vk_helper.py line #939 5531 stp_strs[1] = ""; 5532 stringstream index_ss; 5533 if (pStruct->pViewports) { 5534 for (uint32_t i = 0; i < pStruct->viewportCount; i++) { 5535 index_ss.str(""); 5536 index_ss << i; 5537 // CODEGEN : file ../vk_helper.py line #980 5538 ss[1] << "0x" << &pStruct->pViewports[i]; 5539 tmp_str = vk_print_vkviewport(&pStruct->pViewports[i], extra_indent); 5540 // CODEGEN : file ../vk_helper.py line #984 5541 stp_strs[1] += " " + prefix + "pViewports[" + index_ss.str() + "] (addr)\n" + tmp_str; 5542 // CODEGEN : file ../vk_helper.py line #1000 5543 ss[1].str(""); 5544 } 5545 } 5546 // CODEGEN : file ../vk_helper.py line #932 5547 // CODEGEN : file ../vk_helper.py line #934 5548 // CODEGEN : file ../vk_helper.py line #939 5549 stp_strs[2] = ""; 5550 if (pStruct->pScissors) { 5551 for (uint32_t i = 0; i < pStruct->scissorCount; i++) { 5552 index_ss.str(""); 5553 index_ss << i; 5554 // CODEGEN : file ../vk_helper.py line #980 5555 ss[2] << "0x" << &pStruct->pScissors[i]; 5556 tmp_str = vk_print_vkrect2d(&pStruct->pScissors[i], extra_indent); 5557 // CODEGEN : file ../vk_helper.py line #984 5558 stp_strs[2] += " " + prefix + "pScissors[" + index_ss.str() + "] (addr)\n" + tmp_str; 5559 // CODEGEN : file ../vk_helper.py line #1000 5560 ss[2].str(""); 5561 } 5562 } 5563 // CODEGEN : file ../vk_helper.py line #1070 5564 if (StreamControl::writeAddress) 5565 ss[0] << "0x" << pStruct->pNext; 5566 else 5567 ss[0].str("address"); 5568 // CODEGEN : file ../vk_helper.py line #1086 5569 ss[1] << "0x" << pStruct->flags; 5570 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5571 ss[2] << pStruct->viewportCount; 5572 // CODEGEN : file ../vk_helper.py line #1061 5573 ss[3] << "0x" << (void*)pStruct->pViewports; 5574 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5575 ss[4] << pStruct->scissorCount; 5576 // CODEGEN : file ../vk_helper.py line #1061 5577 ss[5] << "0x" << (void*)pStruct->pScissors; 5578 // CODEGEN : file ../vk_helper.py line #1113 5579 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5580 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5581 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5582 final_str = final_str + prefix + "viewportCount = " + ss[2].str() + "\n"; 5583 final_str = final_str + prefix + "pViewports = " + ss[3].str() + "\n"; 5584 final_str = final_str + prefix + "scissorCount = " + ss[4].str() + "\n"; 5585 final_str = final_str + prefix + "pScissors = " + ss[5].str() + "\n"; 5586 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5587 return final_str; 5588 } 5589 // CODEGEN : file ../vk_helper.py line #907 5590 std::string vk_print_vkpresentinfokhr(const VkPresentInfoKHR* pStruct, const std::string prefix) 5591 { 5592 // CODEGEN : file ../vk_helper.py line #913 5593 using namespace StreamControl; 5594 using namespace std; 5595 string final_str; 5596 string tmp_str; 5597 string extra_indent = " " + prefix; 5598 stringstream ss[7]; 5599 string stp_strs[4]; 5600 // CODEGEN : file ../vk_helper.py line #1012 5601 if (pStruct->pNext) { 5602 // CODEGEN : file ../vk_helper.py line #1016 5603 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5604 ss[0] << "0x" << &pStruct->pNext; 5605 // CODEGEN : file ../vk_helper.py line #1028 5606 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5607 ss[0].str(""); 5608 } 5609 else 5610 stp_strs[0] = ""; 5611 // CODEGEN : file ../vk_helper.py line #932 5612 // CODEGEN : file ../vk_helper.py line #934 5613 // CODEGEN : file ../vk_helper.py line #939 5614 stp_strs[1] = ""; 5615 stringstream index_ss; 5616 if (pStruct->pWaitSemaphores) { 5617 for (uint32_t i = 0; i < pStruct->waitSemaphoreCount; i++) { 5618 index_ss.str(""); 5619 index_ss << i; 5620 // CODEGEN : file ../vk_helper.py line #990 5621 ss[1] << "0x" << pStruct->pWaitSemaphores[i]; 5622 stp_strs[1] += " " + prefix + "pWaitSemaphores[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 5623 // CODEGEN : file ../vk_helper.py line #1000 5624 ss[1].str(""); 5625 } 5626 } 5627 // CODEGEN : file ../vk_helper.py line #932 5628 // CODEGEN : file ../vk_helper.py line #934 5629 // CODEGEN : file ../vk_helper.py line #939 5630 stp_strs[2] = ""; 5631 if (pStruct->pSwapchains) { 5632 for (uint32_t i = 0; i < pStruct->swapchainCount; i++) { 5633 index_ss.str(""); 5634 index_ss << i; 5635 // CODEGEN : file ../vk_helper.py line #990 5636 ss[2] << "0x" << pStruct->pSwapchains[i]; 5637 stp_strs[2] += " " + prefix + "pSwapchains[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 5638 // CODEGEN : file ../vk_helper.py line #1000 5639 ss[2].str(""); 5640 } 5641 } 5642 // CODEGEN : file ../vk_helper.py line #932 5643 // CODEGEN : file ../vk_helper.py line #934 5644 // CODEGEN : file ../vk_helper.py line #939 5645 stp_strs[3] = ""; 5646 if (pStruct->pImageIndices) { 5647 for (uint32_t i = 0; i < pStruct->swapchainCount; i++) { 5648 index_ss.str(""); 5649 index_ss << i; 5650 // CODEGEN : file ../vk_helper.py line #990 5651 ss[3] << "0x" << pStruct->pImageIndices[i]; 5652 stp_strs[3] += " " + prefix + "pImageIndices[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 5653 // CODEGEN : file ../vk_helper.py line #1000 5654 ss[3].str(""); 5655 } 5656 } 5657 // CODEGEN : file ../vk_helper.py line #1070 5658 if (StreamControl::writeAddress) 5659 ss[0] << "0x" << pStruct->pNext; 5660 else 5661 ss[0].str("address"); 5662 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5663 ss[1] << pStruct->waitSemaphoreCount; 5664 // CODEGEN : file ../vk_helper.py line #1061 5665 ss[2] << "0x" << (void*)pStruct->pWaitSemaphores; 5666 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5667 ss[3] << pStruct->swapchainCount; 5668 // CODEGEN : file ../vk_helper.py line #1061 5669 ss[4] << "0x" << (void*)pStruct->pSwapchains; 5670 // CODEGEN : file ../vk_helper.py line #1061 5671 ss[5] << "0x" << (void*)pStruct->pImageIndices; 5672 // CODEGEN : file ../vk_helper.py line #1100 5673 if (pStruct->pResults) 5674 ss[6] << "0x" << pStruct->pResults << " (See individual array values below)"; 5675 else 5676 ss[6].str("NULL"); 5677 // CODEGEN : file ../vk_helper.py line #1113 5678 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5679 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5680 final_str = final_str + prefix + "waitSemaphoreCount = " + ss[1].str() + "\n"; 5681 final_str = final_str + prefix + "pWaitSemaphores = " + ss[2].str() + "\n"; 5682 final_str = final_str + prefix + "swapchainCount = " + ss[3].str() + "\n"; 5683 final_str = final_str + prefix + "pSwapchains = " + ss[4].str() + "\n"; 5684 final_str = final_str + prefix + "pImageIndices = " + ss[5].str() + "\n"; 5685 final_str = final_str + prefix + "pResults = " + ss[6].str() + "\n"; 5686 final_str = final_str + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5687 return final_str; 5688 } 5689 // CODEGEN : file ../vk_helper.py line #907 5690 std::string vk_print_vkpushconstantrange(const VkPushConstantRange* pStruct, const std::string prefix) 5691 { 5692 // CODEGEN : file ../vk_helper.py line #913 5693 using namespace StreamControl; 5694 using namespace std; 5695 string final_str; 5696 string tmp_str; 5697 string extra_indent = " " + prefix; 5698 stringstream ss[3]; 5699 // CODEGEN : file ../vk_helper.py line #1086 5700 ss[0] << "0x" << pStruct->stageFlags; 5701 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 5702 ss[1] << "0x" << pStruct->offset; 5703 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5704 ss[2] << pStruct->size; 5705 // CODEGEN : file ../vk_helper.py line #1113 5706 final_str = final_str + prefix + "stageFlags = " + ss[0].str() + "\n"; 5707 final_str = final_str + prefix + "offset = " + ss[1].str() + "\n"; 5708 final_str = final_str + prefix + "size = " + ss[2].str() + "\n"; 5709 return final_str; 5710 } 5711 // CODEGEN : file ../vk_helper.py line #907 5712 std::string vk_print_vkquerypoolcreateinfo(const VkQueryPoolCreateInfo* pStruct, const std::string prefix) 5713 { 5714 // CODEGEN : file ../vk_helper.py line #913 5715 using namespace StreamControl; 5716 using namespace std; 5717 string final_str; 5718 string tmp_str; 5719 string extra_indent = " " + prefix; 5720 stringstream ss[4]; 5721 string stp_strs[1]; 5722 // CODEGEN : file ../vk_helper.py line #1012 5723 if (pStruct->pNext) { 5724 // CODEGEN : file ../vk_helper.py line #1016 5725 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5726 ss[0] << "0x" << &pStruct->pNext; 5727 // CODEGEN : file ../vk_helper.py line #1028 5728 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5729 ss[0].str(""); 5730 } 5731 else 5732 stp_strs[0] = ""; 5733 // CODEGEN : file ../vk_helper.py line #1070 5734 if (StreamControl::writeAddress) 5735 ss[0] << "0x" << pStruct->pNext; 5736 else 5737 ss[0].str("address"); 5738 // CODEGEN : file ../vk_helper.py line #1086 5739 ss[1] << "0x" << pStruct->flags; 5740 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5741 ss[2] << pStruct->queryCount; 5742 // CODEGEN : file ../vk_helper.py line #1086 5743 ss[3] << "0x" << pStruct->pipelineStatistics; 5744 // CODEGEN : file ../vk_helper.py line #1113 5745 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5746 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5747 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5748 final_str = final_str + prefix + "queryType = " + string_VkQueryType(pStruct->queryType) + "\n"; 5749 final_str = final_str + prefix + "queryCount = " + ss[2].str() + "\n"; 5750 final_str = final_str + prefix + "pipelineStatistics = " + ss[3].str() + "\n"; 5751 final_str = final_str + stp_strs[0]; 5752 return final_str; 5753 } 5754 // CODEGEN : file ../vk_helper.py line #907 5755 std::string vk_print_vkqueuefamilyproperties(const VkQueueFamilyProperties* pStruct, const std::string prefix) 5756 { 5757 // CODEGEN : file ../vk_helper.py line #913 5758 using namespace StreamControl; 5759 using namespace std; 5760 string final_str; 5761 string tmp_str; 5762 string extra_indent = " " + prefix; 5763 stringstream ss[4]; 5764 string stp_strs[1]; 5765 // CODEGEN : file ../vk_helper.py line #1038 5766 tmp_str = vk_print_vkextent3d(&pStruct->minImageTransferGranularity, extra_indent); 5767 ss[0] << "0x" << &pStruct->minImageTransferGranularity; 5768 stp_strs[0] = " " + prefix + "minImageTransferGranularity (addr)\n" + tmp_str; 5769 // CODEGEN : file ../vk_helper.py line #1043 5770 ss[0].str(""); 5771 // CODEGEN : file ../vk_helper.py line #1086 5772 ss[0] << "0x" << pStruct->queueFlags; 5773 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5774 ss[1] << pStruct->queueCount; 5775 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 5776 ss[2] << "0x" << pStruct->timestampValidBits; 5777 // CODEGEN : file ../vk_helper.py line #1055 5778 ss[3].str("addr"); 5779 // CODEGEN : file ../vk_helper.py line #1113 5780 final_str = final_str + prefix + "queueFlags = " + ss[0].str() + "\n"; 5781 final_str = final_str + prefix + "queueCount = " + ss[1].str() + "\n"; 5782 final_str = final_str + prefix + "timestampValidBits = " + ss[2].str() + "\n"; 5783 final_str = final_str + prefix + "minImageTransferGranularity = " + ss[3].str() + "\n"; 5784 final_str = final_str + stp_strs[0]; 5785 return final_str; 5786 } 5787 // CODEGEN : file ../vk_helper.py line #907 5788 std::string vk_print_vkrect2d(const VkRect2D* pStruct, const std::string prefix) 5789 { 5790 // CODEGEN : file ../vk_helper.py line #913 5791 using namespace StreamControl; 5792 using namespace std; 5793 string final_str; 5794 string tmp_str; 5795 string extra_indent = " " + prefix; 5796 stringstream ss[2]; 5797 string stp_strs[2]; 5798 // CODEGEN : file ../vk_helper.py line #1038 5799 tmp_str = vk_print_vkoffset2d(&pStruct->offset, extra_indent); 5800 ss[0] << "0x" << &pStruct->offset; 5801 stp_strs[0] = " " + prefix + "offset (addr)\n" + tmp_str; 5802 // CODEGEN : file ../vk_helper.py line #1043 5803 ss[0].str(""); 5804 // CODEGEN : file ../vk_helper.py line #1038 5805 tmp_str = vk_print_vkextent2d(&pStruct->extent, extra_indent); 5806 ss[1] << "0x" << &pStruct->extent; 5807 stp_strs[1] = " " + prefix + "extent (addr)\n" + tmp_str; 5808 // CODEGEN : file ../vk_helper.py line #1043 5809 ss[1].str(""); 5810 // CODEGEN : file ../vk_helper.py line #1055 5811 ss[0].str("addr"); 5812 // CODEGEN : file ../vk_helper.py line #1055 5813 ss[1].str("addr"); 5814 // CODEGEN : file ../vk_helper.py line #1113 5815 final_str = final_str + prefix + "offset = " + ss[0].str() + "\n"; 5816 final_str = final_str + prefix + "extent = " + ss[1].str() + "\n"; 5817 final_str = final_str + stp_strs[1] + stp_strs[0]; 5818 return final_str; 5819 } 5820 // CODEGEN : file ../vk_helper.py line #907 5821 std::string vk_print_vkrenderpassbegininfo(const VkRenderPassBeginInfo* pStruct, const std::string prefix) 5822 { 5823 // CODEGEN : file ../vk_helper.py line #913 5824 using namespace StreamControl; 5825 using namespace std; 5826 string final_str; 5827 string tmp_str; 5828 string extra_indent = " " + prefix; 5829 stringstream ss[6]; 5830 string stp_strs[3]; 5831 // CODEGEN : file ../vk_helper.py line #1012 5832 if (pStruct->pNext) { 5833 // CODEGEN : file ../vk_helper.py line #1016 5834 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5835 ss[0] << "0x" << &pStruct->pNext; 5836 // CODEGEN : file ../vk_helper.py line #1028 5837 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5838 ss[0].str(""); 5839 } 5840 else 5841 stp_strs[0] = ""; 5842 // CODEGEN : file ../vk_helper.py line #1038 5843 tmp_str = vk_print_vkrect2d(&pStruct->renderArea, extra_indent); 5844 ss[1] << "0x" << &pStruct->renderArea; 5845 stp_strs[1] = " " + prefix + "renderArea (addr)\n" + tmp_str; 5846 // CODEGEN : file ../vk_helper.py line #1043 5847 ss[1].str(""); 5848 // CODEGEN : file ../vk_helper.py line #932 5849 // CODEGEN : file ../vk_helper.py line #934 5850 // CODEGEN : file ../vk_helper.py line #939 5851 stp_strs[2] = ""; 5852 stringstream index_ss; 5853 if (pStruct->pClearValues) { 5854 for (uint32_t i = 0; i < pStruct->clearValueCount; i++) { 5855 index_ss.str(""); 5856 index_ss << i; 5857 // CODEGEN : file ../vk_helper.py line #980 5858 ss[2] << "0x" << &pStruct->pClearValues[i]; 5859 tmp_str = vk_print_vkclearvalue(&pStruct->pClearValues[i], extra_indent); 5860 // CODEGEN : file ../vk_helper.py line #984 5861 stp_strs[2] += " " + prefix + "pClearValues[" + index_ss.str() + "] (addr)\n" + tmp_str; 5862 // CODEGEN : file ../vk_helper.py line #1000 5863 ss[2].str(""); 5864 } 5865 } 5866 // CODEGEN : file ../vk_helper.py line #1070 5867 if (StreamControl::writeAddress) 5868 ss[0] << "0x" << pStruct->pNext; 5869 else 5870 ss[0].str("address"); 5871 // CODEGEN : file ../vk_helper.py line #1086 5872 ss[1] << "0x" << pStruct->renderPass; 5873 // CODEGEN : file ../vk_helper.py line #1086 5874 ss[2] << "0x" << pStruct->framebuffer; 5875 // CODEGEN : file ../vk_helper.py line #1055 5876 ss[3].str("addr"); 5877 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5878 ss[4] << pStruct->clearValueCount; 5879 // CODEGEN : file ../vk_helper.py line #1061 5880 ss[5] << "0x" << (void*)pStruct->pClearValues; 5881 // CODEGEN : file ../vk_helper.py line #1113 5882 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5883 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5884 final_str = final_str + prefix + "renderPass = " + ss[1].str() + "\n"; 5885 final_str = final_str + prefix + "framebuffer = " + ss[2].str() + "\n"; 5886 final_str = final_str + prefix + "renderArea = " + ss[3].str() + "\n"; 5887 final_str = final_str + prefix + "clearValueCount = " + ss[4].str() + "\n"; 5888 final_str = final_str + prefix + "pClearValues = " + ss[5].str() + "\n"; 5889 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5890 return final_str; 5891 } 5892 // CODEGEN : file ../vk_helper.py line #907 5893 std::string vk_print_vkrenderpasscreateinfo(const VkRenderPassCreateInfo* pStruct, const std::string prefix) 5894 { 5895 // CODEGEN : file ../vk_helper.py line #913 5896 using namespace StreamControl; 5897 using namespace std; 5898 string final_str; 5899 string tmp_str; 5900 string extra_indent = " " + prefix; 5901 stringstream ss[8]; 5902 string stp_strs[4]; 5903 // CODEGEN : file ../vk_helper.py line #1012 5904 if (pStruct->pNext) { 5905 // CODEGEN : file ../vk_helper.py line #1016 5906 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 5907 ss[0] << "0x" << &pStruct->pNext; 5908 // CODEGEN : file ../vk_helper.py line #1028 5909 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 5910 ss[0].str(""); 5911 } 5912 else 5913 stp_strs[0] = ""; 5914 // CODEGEN : file ../vk_helper.py line #932 5915 // CODEGEN : file ../vk_helper.py line #934 5916 // CODEGEN : file ../vk_helper.py line #939 5917 stp_strs[1] = ""; 5918 stringstream index_ss; 5919 if (pStruct->pAttachments) { 5920 for (uint32_t i = 0; i < pStruct->attachmentCount; i++) { 5921 index_ss.str(""); 5922 index_ss << i; 5923 // CODEGEN : file ../vk_helper.py line #980 5924 ss[1] << "0x" << &pStruct->pAttachments[i]; 5925 tmp_str = vk_print_vkattachmentdescription(&pStruct->pAttachments[i], extra_indent); 5926 // CODEGEN : file ../vk_helper.py line #984 5927 stp_strs[1] += " " + prefix + "pAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 5928 // CODEGEN : file ../vk_helper.py line #1000 5929 ss[1].str(""); 5930 } 5931 } 5932 // CODEGEN : file ../vk_helper.py line #932 5933 // CODEGEN : file ../vk_helper.py line #934 5934 // CODEGEN : file ../vk_helper.py line #939 5935 stp_strs[2] = ""; 5936 if (pStruct->pSubpasses) { 5937 for (uint32_t i = 0; i < pStruct->subpassCount; i++) { 5938 index_ss.str(""); 5939 index_ss << i; 5940 // CODEGEN : file ../vk_helper.py line #980 5941 ss[2] << "0x" << &pStruct->pSubpasses[i]; 5942 tmp_str = vk_print_vksubpassdescription(&pStruct->pSubpasses[i], extra_indent); 5943 // CODEGEN : file ../vk_helper.py line #984 5944 stp_strs[2] += " " + prefix + "pSubpasses[" + index_ss.str() + "] (addr)\n" + tmp_str; 5945 // CODEGEN : file ../vk_helper.py line #1000 5946 ss[2].str(""); 5947 } 5948 } 5949 // CODEGEN : file ../vk_helper.py line #932 5950 // CODEGEN : file ../vk_helper.py line #934 5951 // CODEGEN : file ../vk_helper.py line #939 5952 stp_strs[3] = ""; 5953 if (pStruct->pDependencies) { 5954 for (uint32_t i = 0; i < pStruct->dependencyCount; i++) { 5955 index_ss.str(""); 5956 index_ss << i; 5957 // CODEGEN : file ../vk_helper.py line #980 5958 ss[3] << "0x" << &pStruct->pDependencies[i]; 5959 tmp_str = vk_print_vksubpassdependency(&pStruct->pDependencies[i], extra_indent); 5960 // CODEGEN : file ../vk_helper.py line #984 5961 stp_strs[3] += " " + prefix + "pDependencies[" + index_ss.str() + "] (addr)\n" + tmp_str; 5962 // CODEGEN : file ../vk_helper.py line #1000 5963 ss[3].str(""); 5964 } 5965 } 5966 // CODEGEN : file ../vk_helper.py line #1070 5967 if (StreamControl::writeAddress) 5968 ss[0] << "0x" << pStruct->pNext; 5969 else 5970 ss[0].str("address"); 5971 // CODEGEN : file ../vk_helper.py line #1086 5972 ss[1] << "0x" << pStruct->flags; 5973 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5974 ss[2] << pStruct->attachmentCount; 5975 // CODEGEN : file ../vk_helper.py line #1061 5976 ss[3] << "0x" << (void*)pStruct->pAttachments; 5977 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5978 ss[4] << pStruct->subpassCount; 5979 // CODEGEN : file ../vk_helper.py line #1061 5980 ss[5] << "0x" << (void*)pStruct->pSubpasses; 5981 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 5982 ss[6] << pStruct->dependencyCount; 5983 // CODEGEN : file ../vk_helper.py line #1061 5984 ss[7] << "0x" << (void*)pStruct->pDependencies; 5985 // CODEGEN : file ../vk_helper.py line #1113 5986 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 5987 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 5988 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 5989 final_str = final_str + prefix + "attachmentCount = " + ss[2].str() + "\n"; 5990 final_str = final_str + prefix + "pAttachments = " + ss[3].str() + "\n"; 5991 final_str = final_str + prefix + "subpassCount = " + ss[4].str() + "\n"; 5992 final_str = final_str + prefix + "pSubpasses = " + ss[5].str() + "\n"; 5993 final_str = final_str + prefix + "dependencyCount = " + ss[6].str() + "\n"; 5994 final_str = final_str + prefix + "pDependencies = " + ss[7].str() + "\n"; 5995 final_str = final_str + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 5996 return final_str; 5997 } 5998 // CODEGEN : file ../vk_helper.py line #907 5999 std::string vk_print_vksamplercreateinfo(const VkSamplerCreateInfo* pStruct, const std::string prefix) 6000 { 6001 // CODEGEN : file ../vk_helper.py line #913 6002 using namespace StreamControl; 6003 using namespace std; 6004 string final_str; 6005 string tmp_str; 6006 string extra_indent = " " + prefix; 6007 stringstream ss[9]; 6008 string stp_strs[1]; 6009 // CODEGEN : file ../vk_helper.py line #1012 6010 if (pStruct->pNext) { 6011 // CODEGEN : file ../vk_helper.py line #1016 6012 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 6013 ss[0] << "0x" << &pStruct->pNext; 6014 // CODEGEN : file ../vk_helper.py line #1028 6015 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 6016 ss[0].str(""); 6017 } 6018 else 6019 stp_strs[0] = ""; 6020 // CODEGEN : file ../vk_helper.py line #1070 6021 if (StreamControl::writeAddress) 6022 ss[0] << "0x" << pStruct->pNext; 6023 else 6024 ss[0].str("address"); 6025 // CODEGEN : file ../vk_helper.py line #1086 6026 ss[1] << "0x" << pStruct->flags; 6027 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6028 ss[2] << pStruct->mipLodBias; 6029 // CODEGEN : file ../vk_helper.py line #1064 6030 ss[3].str(pStruct->anisotropyEnable ? "TRUE" : "FALSE"); 6031 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6032 ss[4] << pStruct->maxAnisotropy; 6033 // CODEGEN : file ../vk_helper.py line #1064 6034 ss[5].str(pStruct->compareEnable ? "TRUE" : "FALSE"); 6035 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6036 ss[6] << pStruct->minLod; 6037 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6038 ss[7] << pStruct->maxLod; 6039 // CODEGEN : file ../vk_helper.py line #1064 6040 ss[8].str(pStruct->unnormalizedCoordinates ? "TRUE" : "FALSE"); 6041 // CODEGEN : file ../vk_helper.py line #1113 6042 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 6043 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 6044 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 6045 final_str = final_str + prefix + "magFilter = " + string_VkFilter(pStruct->magFilter) + "\n"; 6046 final_str = final_str + prefix + "minFilter = " + string_VkFilter(pStruct->minFilter) + "\n"; 6047 final_str = final_str + prefix + "mipmapMode = " + string_VkSamplerMipmapMode(pStruct->mipmapMode) + "\n"; 6048 final_str = final_str + prefix + "addressModeU = " + string_VkSamplerAddressMode(pStruct->addressModeU) + "\n"; 6049 final_str = final_str + prefix + "addressModeV = " + string_VkSamplerAddressMode(pStruct->addressModeV) + "\n"; 6050 final_str = final_str + prefix + "addressModeW = " + string_VkSamplerAddressMode(pStruct->addressModeW) + "\n"; 6051 final_str = final_str + prefix + "mipLodBias = " + ss[2].str() + "\n"; 6052 final_str = final_str + prefix + "anisotropyEnable = " + ss[3].str() + "\n"; 6053 final_str = final_str + prefix + "maxAnisotropy = " + ss[4].str() + "\n"; 6054 final_str = final_str + prefix + "compareEnable = " + ss[5].str() + "\n"; 6055 final_str = final_str + prefix + "compareOp = " + string_VkCompareOp(pStruct->compareOp) + "\n"; 6056 final_str = final_str + prefix + "minLod = " + ss[6].str() + "\n"; 6057 final_str = final_str + prefix + "maxLod = " + ss[7].str() + "\n"; 6058 final_str = final_str + prefix + "borderColor = " + string_VkBorderColor(pStruct->borderColor) + "\n"; 6059 final_str = final_str + prefix + "unnormalizedCoordinates = " + ss[8].str() + "\n"; 6060 final_str = final_str + stp_strs[0]; 6061 return final_str; 6062 } 6063 // CODEGEN : file ../vk_helper.py line #907 6064 std::string vk_print_vksemaphorecreateinfo(const VkSemaphoreCreateInfo* pStruct, const std::string prefix) 6065 { 6066 // CODEGEN : file ../vk_helper.py line #913 6067 using namespace StreamControl; 6068 using namespace std; 6069 string final_str; 6070 string tmp_str; 6071 string extra_indent = " " + prefix; 6072 stringstream ss[2]; 6073 string stp_strs[1]; 6074 // CODEGEN : file ../vk_helper.py line #1012 6075 if (pStruct->pNext) { 6076 // CODEGEN : file ../vk_helper.py line #1016 6077 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 6078 ss[0] << "0x" << &pStruct->pNext; 6079 // CODEGEN : file ../vk_helper.py line #1028 6080 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 6081 ss[0].str(""); 6082 } 6083 else 6084 stp_strs[0] = ""; 6085 // CODEGEN : file ../vk_helper.py line #1070 6086 if (StreamControl::writeAddress) 6087 ss[0] << "0x" << pStruct->pNext; 6088 else 6089 ss[0].str("address"); 6090 // CODEGEN : file ../vk_helper.py line #1086 6091 ss[1] << "0x" << pStruct->flags; 6092 // CODEGEN : file ../vk_helper.py line #1113 6093 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 6094 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 6095 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 6096 final_str = final_str + stp_strs[0]; 6097 return final_str; 6098 } 6099 // CODEGEN : file ../vk_helper.py line #907 6100 std::string vk_print_vkshadermodulecreateinfo(const VkShaderModuleCreateInfo* pStruct, const std::string prefix) 6101 { 6102 // CODEGEN : file ../vk_helper.py line #913 6103 using namespace StreamControl; 6104 using namespace std; 6105 string final_str; 6106 string tmp_str; 6107 string extra_indent = " " + prefix; 6108 stringstream ss[4]; 6109 string stp_strs[1]; 6110 // CODEGEN : file ../vk_helper.py line #1012 6111 if (pStruct->pNext) { 6112 // CODEGEN : file ../vk_helper.py line #1016 6113 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 6114 ss[0] << "0x" << &pStruct->pNext; 6115 // CODEGEN : file ../vk_helper.py line #1028 6116 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 6117 ss[0].str(""); 6118 } 6119 else 6120 stp_strs[0] = ""; 6121 // CODEGEN : file ../vk_helper.py line #1070 6122 if (StreamControl::writeAddress) 6123 ss[0] << "0x" << pStruct->pNext; 6124 else 6125 ss[0].str("address"); 6126 // CODEGEN : file ../vk_helper.py line #1086 6127 ss[1] << "0x" << pStruct->flags; 6128 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6129 ss[2] << pStruct->codeSize; 6130 // CODEGEN : file ../vk_helper.py line #1086 6131 ss[3] << "0x" << pStruct->pCode; 6132 // CODEGEN : file ../vk_helper.py line #1113 6133 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 6134 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 6135 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 6136 final_str = final_str + prefix + "codeSize = " + ss[2].str() + "\n"; 6137 final_str = final_str + prefix + "pCode = " + ss[3].str() + "\n"; 6138 final_str = final_str + stp_strs[0]; 6139 return final_str; 6140 } 6141 // CODEGEN : file ../vk_helper.py line #907 6142 std::string vk_print_vksparsebuffermemorybindinfo(const VkSparseBufferMemoryBindInfo* pStruct, const std::string prefix) 6143 { 6144 // CODEGEN : file ../vk_helper.py line #913 6145 using namespace StreamControl; 6146 using namespace std; 6147 string final_str; 6148 string tmp_str; 6149 string extra_indent = " " + prefix; 6150 stringstream ss[3]; 6151 string stp_strs[1]; 6152 // CODEGEN : file ../vk_helper.py line #932 6153 // CODEGEN : file ../vk_helper.py line #934 6154 // CODEGEN : file ../vk_helper.py line #939 6155 stp_strs[0] = ""; 6156 stringstream index_ss; 6157 if (pStruct->pBinds) { 6158 for (uint32_t i = 0; i < pStruct->bindCount; i++) { 6159 index_ss.str(""); 6160 index_ss << i; 6161 // CODEGEN : file ../vk_helper.py line #980 6162 ss[0] << "0x" << &pStruct->pBinds[i]; 6163 tmp_str = vk_print_vksparsememorybind(&pStruct->pBinds[i], extra_indent); 6164 // CODEGEN : file ../vk_helper.py line #984 6165 stp_strs[0] += " " + prefix + "pBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 6166 // CODEGEN : file ../vk_helper.py line #1000 6167 ss[0].str(""); 6168 } 6169 } 6170 // CODEGEN : file ../vk_helper.py line #1086 6171 ss[0] << "0x" << pStruct->buffer; 6172 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6173 ss[1] << pStruct->bindCount; 6174 // CODEGEN : file ../vk_helper.py line #1061 6175 ss[2] << "0x" << (void*)pStruct->pBinds; 6176 // CODEGEN : file ../vk_helper.py line #1113 6177 final_str = final_str + prefix + "buffer = " + ss[0].str() + "\n"; 6178 final_str = final_str + prefix + "bindCount = " + ss[1].str() + "\n"; 6179 final_str = final_str + prefix + "pBinds = " + ss[2].str() + "\n"; 6180 final_str = final_str + stp_strs[0]; 6181 return final_str; 6182 } 6183 // CODEGEN : file ../vk_helper.py line #907 6184 std::string vk_print_vksparseimageformatproperties(const VkSparseImageFormatProperties* pStruct, const std::string prefix) 6185 { 6186 // CODEGEN : file ../vk_helper.py line #913 6187 using namespace StreamControl; 6188 using namespace std; 6189 string final_str; 6190 string tmp_str; 6191 string extra_indent = " " + prefix; 6192 stringstream ss[3]; 6193 string stp_strs[1]; 6194 // CODEGEN : file ../vk_helper.py line #1038 6195 tmp_str = vk_print_vkextent3d(&pStruct->imageGranularity, extra_indent); 6196 ss[0] << "0x" << &pStruct->imageGranularity; 6197 stp_strs[0] = " " + prefix + "imageGranularity (addr)\n" + tmp_str; 6198 // CODEGEN : file ../vk_helper.py line #1043 6199 ss[0].str(""); 6200 // CODEGEN : file ../vk_helper.py line #1086 6201 ss[0] << "0x" << pStruct->aspectMask; 6202 // CODEGEN : file ../vk_helper.py line #1055 6203 ss[1].str("addr"); 6204 // CODEGEN : file ../vk_helper.py line #1086 6205 ss[2] << "0x" << pStruct->flags; 6206 // CODEGEN : file ../vk_helper.py line #1113 6207 final_str = final_str + prefix + "aspectMask = " + ss[0].str() + "\n"; 6208 final_str = final_str + prefix + "imageGranularity = " + ss[1].str() + "\n"; 6209 final_str = final_str + prefix + "flags = " + ss[2].str() + "\n"; 6210 final_str = final_str + stp_strs[0]; 6211 return final_str; 6212 } 6213 // CODEGEN : file ../vk_helper.py line #907 6214 std::string vk_print_vksparseimagememorybind(const VkSparseImageMemoryBind* pStruct, const std::string prefix) 6215 { 6216 // CODEGEN : file ../vk_helper.py line #913 6217 using namespace StreamControl; 6218 using namespace std; 6219 string final_str; 6220 string tmp_str; 6221 string extra_indent = " " + prefix; 6222 stringstream ss[6]; 6223 string stp_strs[3]; 6224 // CODEGEN : file ../vk_helper.py line #1038 6225 tmp_str = vk_print_vkimagesubresource(&pStruct->subresource, extra_indent); 6226 ss[0] << "0x" << &pStruct->subresource; 6227 stp_strs[0] = " " + prefix + "subresource (addr)\n" + tmp_str; 6228 // CODEGEN : file ../vk_helper.py line #1043 6229 ss[0].str(""); 6230 // CODEGEN : file ../vk_helper.py line #1038 6231 tmp_str = vk_print_vkoffset3d(&pStruct->offset, extra_indent); 6232 ss[1] << "0x" << &pStruct->offset; 6233 stp_strs[1] = " " + prefix + "offset (addr)\n" + tmp_str; 6234 // CODEGEN : file ../vk_helper.py line #1043 6235 ss[1].str(""); 6236 // CODEGEN : file ../vk_helper.py line #1038 6237 tmp_str = vk_print_vkextent3d(&pStruct->extent, extra_indent); 6238 ss[2] << "0x" << &pStruct->extent; 6239 stp_strs[2] = " " + prefix + "extent (addr)\n" + tmp_str; 6240 // CODEGEN : file ../vk_helper.py line #1043 6241 ss[2].str(""); 6242 // CODEGEN : file ../vk_helper.py line #1055 6243 ss[0].str("addr"); 6244 // CODEGEN : file ../vk_helper.py line #1055 6245 ss[1].str("addr"); 6246 // CODEGEN : file ../vk_helper.py line #1055 6247 ss[2].str("addr"); 6248 // CODEGEN : file ../vk_helper.py line #1086 6249 ss[3] << "0x" << pStruct->memory; 6250 // CODEGEN : file ../vk_helper.py line #1086 6251 ss[4] << "0x" << pStruct->memoryOffset; 6252 // CODEGEN : file ../vk_helper.py line #1086 6253 ss[5] << "0x" << pStruct->flags; 6254 // CODEGEN : file ../vk_helper.py line #1113 6255 final_str = final_str + prefix + "subresource = " + ss[0].str() + "\n"; 6256 final_str = final_str + prefix + "offset = " + ss[1].str() + "\n"; 6257 final_str = final_str + prefix + "extent = " + ss[2].str() + "\n"; 6258 final_str = final_str + prefix + "memory = " + ss[3].str() + "\n"; 6259 final_str = final_str + prefix + "memoryOffset = " + ss[4].str() + "\n"; 6260 final_str = final_str + prefix + "flags = " + ss[5].str() + "\n"; 6261 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 6262 return final_str; 6263 } 6264 // CODEGEN : file ../vk_helper.py line #907 6265 std::string vk_print_vksparseimagememorybindinfo(const VkSparseImageMemoryBindInfo* pStruct, const std::string prefix) 6266 { 6267 // CODEGEN : file ../vk_helper.py line #913 6268 using namespace StreamControl; 6269 using namespace std; 6270 string final_str; 6271 string tmp_str; 6272 string extra_indent = " " + prefix; 6273 stringstream ss[3]; 6274 string stp_strs[1]; 6275 // CODEGEN : file ../vk_helper.py line #932 6276 // CODEGEN : file ../vk_helper.py line #934 6277 // CODEGEN : file ../vk_helper.py line #939 6278 stp_strs[0] = ""; 6279 stringstream index_ss; 6280 if (pStruct->pBinds) { 6281 for (uint32_t i = 0; i < pStruct->bindCount; i++) { 6282 index_ss.str(""); 6283 index_ss << i; 6284 // CODEGEN : file ../vk_helper.py line #980 6285 ss[0] << "0x" << &pStruct->pBinds[i]; 6286 tmp_str = vk_print_vksparseimagememorybind(&pStruct->pBinds[i], extra_indent); 6287 // CODEGEN : file ../vk_helper.py line #984 6288 stp_strs[0] += " " + prefix + "pBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 6289 // CODEGEN : file ../vk_helper.py line #1000 6290 ss[0].str(""); 6291 } 6292 } 6293 // CODEGEN : file ../vk_helper.py line #1086 6294 ss[0] << "0x" << pStruct->image; 6295 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6296 ss[1] << pStruct->bindCount; 6297 // CODEGEN : file ../vk_helper.py line #1061 6298 ss[2] << "0x" << (void*)pStruct->pBinds; 6299 // CODEGEN : file ../vk_helper.py line #1113 6300 final_str = final_str + prefix + "image = " + ss[0].str() + "\n"; 6301 final_str = final_str + prefix + "bindCount = " + ss[1].str() + "\n"; 6302 final_str = final_str + prefix + "pBinds = " + ss[2].str() + "\n"; 6303 final_str = final_str + stp_strs[0]; 6304 return final_str; 6305 } 6306 // CODEGEN : file ../vk_helper.py line #907 6307 std::string vk_print_vksparseimagememoryrequirements(const VkSparseImageMemoryRequirements* pStruct, const std::string prefix) 6308 { 6309 // CODEGEN : file ../vk_helper.py line #913 6310 using namespace StreamControl; 6311 using namespace std; 6312 string final_str; 6313 string tmp_str; 6314 string extra_indent = " " + prefix; 6315 stringstream ss[5]; 6316 string stp_strs[1]; 6317 // CODEGEN : file ../vk_helper.py line #1038 6318 tmp_str = vk_print_vksparseimageformatproperties(&pStruct->formatProperties, extra_indent); 6319 ss[0] << "0x" << &pStruct->formatProperties; 6320 stp_strs[0] = " " + prefix + "formatProperties (addr)\n" + tmp_str; 6321 // CODEGEN : file ../vk_helper.py line #1043 6322 ss[0].str(""); 6323 // CODEGEN : file ../vk_helper.py line #1055 6324 ss[0].str("addr"); 6325 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6326 ss[1] << pStruct->imageMipTailFirstLod; 6327 // CODEGEN : file ../vk_helper.py line #1086 6328 ss[2] << "0x" << pStruct->imageMipTailSize; 6329 // CODEGEN : file ../vk_helper.py line #1086 6330 ss[3] << "0x" << pStruct->imageMipTailOffset; 6331 // CODEGEN : file ../vk_helper.py line #1086 6332 ss[4] << "0x" << pStruct->imageMipTailStride; 6333 // CODEGEN : file ../vk_helper.py line #1113 6334 final_str = final_str + prefix + "formatProperties = " + ss[0].str() + "\n"; 6335 final_str = final_str + prefix + "imageMipTailFirstLod = " + ss[1].str() + "\n"; 6336 final_str = final_str + prefix + "imageMipTailSize = " + ss[2].str() + "\n"; 6337 final_str = final_str + prefix + "imageMipTailOffset = " + ss[3].str() + "\n"; 6338 final_str = final_str + prefix + "imageMipTailStride = " + ss[4].str() + "\n"; 6339 final_str = final_str + stp_strs[0]; 6340 return final_str; 6341 } 6342 // CODEGEN : file ../vk_helper.py line #907 6343 std::string vk_print_vksparseimageopaquememorybindinfo(const VkSparseImageOpaqueMemoryBindInfo* pStruct, const std::string prefix) 6344 { 6345 // CODEGEN : file ../vk_helper.py line #913 6346 using namespace StreamControl; 6347 using namespace std; 6348 string final_str; 6349 string tmp_str; 6350 string extra_indent = " " + prefix; 6351 stringstream ss[3]; 6352 string stp_strs[1]; 6353 // CODEGEN : file ../vk_helper.py line #932 6354 // CODEGEN : file ../vk_helper.py line #934 6355 // CODEGEN : file ../vk_helper.py line #939 6356 stp_strs[0] = ""; 6357 stringstream index_ss; 6358 if (pStruct->pBinds) { 6359 for (uint32_t i = 0; i < pStruct->bindCount; i++) { 6360 index_ss.str(""); 6361 index_ss << i; 6362 // CODEGEN : file ../vk_helper.py line #980 6363 ss[0] << "0x" << &pStruct->pBinds[i]; 6364 tmp_str = vk_print_vksparsememorybind(&pStruct->pBinds[i], extra_indent); 6365 // CODEGEN : file ../vk_helper.py line #984 6366 stp_strs[0] += " " + prefix + "pBinds[" + index_ss.str() + "] (addr)\n" + tmp_str; 6367 // CODEGEN : file ../vk_helper.py line #1000 6368 ss[0].str(""); 6369 } 6370 } 6371 // CODEGEN : file ../vk_helper.py line #1086 6372 ss[0] << "0x" << pStruct->image; 6373 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6374 ss[1] << pStruct->bindCount; 6375 // CODEGEN : file ../vk_helper.py line #1061 6376 ss[2] << "0x" << (void*)pStruct->pBinds; 6377 // CODEGEN : file ../vk_helper.py line #1113 6378 final_str = final_str + prefix + "image = " + ss[0].str() + "\n"; 6379 final_str = final_str + prefix + "bindCount = " + ss[1].str() + "\n"; 6380 final_str = final_str + prefix + "pBinds = " + ss[2].str() + "\n"; 6381 final_str = final_str + stp_strs[0]; 6382 return final_str; 6383 } 6384 // CODEGEN : file ../vk_helper.py line #907 6385 std::string vk_print_vksparsememorybind(const VkSparseMemoryBind* pStruct, const std::string prefix) 6386 { 6387 // CODEGEN : file ../vk_helper.py line #913 6388 using namespace StreamControl; 6389 using namespace std; 6390 string final_str; 6391 string tmp_str; 6392 string extra_indent = " " + prefix; 6393 stringstream ss[5]; 6394 // CODEGEN : file ../vk_helper.py line #1086 6395 ss[0] << "0x" << pStruct->resourceOffset; 6396 // CODEGEN : file ../vk_helper.py line #1086 6397 ss[1] << "0x" << pStruct->size; 6398 // CODEGEN : file ../vk_helper.py line #1086 6399 ss[2] << "0x" << pStruct->memory; 6400 // CODEGEN : file ../vk_helper.py line #1086 6401 ss[3] << "0x" << pStruct->memoryOffset; 6402 // CODEGEN : file ../vk_helper.py line #1086 6403 ss[4] << "0x" << pStruct->flags; 6404 // CODEGEN : file ../vk_helper.py line #1113 6405 final_str = final_str + prefix + "resourceOffset = " + ss[0].str() + "\n"; 6406 final_str = final_str + prefix + "size = " + ss[1].str() + "\n"; 6407 final_str = final_str + prefix + "memory = " + ss[2].str() + "\n"; 6408 final_str = final_str + prefix + "memoryOffset = " + ss[3].str() + "\n"; 6409 final_str = final_str + prefix + "flags = " + ss[4].str() + "\n"; 6410 return final_str; 6411 } 6412 // CODEGEN : file ../vk_helper.py line #907 6413 std::string vk_print_vkspecializationinfo(const VkSpecializationInfo* pStruct, const std::string prefix) 6414 { 6415 // CODEGEN : file ../vk_helper.py line #913 6416 using namespace StreamControl; 6417 using namespace std; 6418 string final_str; 6419 string tmp_str; 6420 string extra_indent = " " + prefix; 6421 stringstream ss[4]; 6422 string stp_strs[1]; 6423 // CODEGEN : file ../vk_helper.py line #932 6424 // CODEGEN : file ../vk_helper.py line #934 6425 // CODEGEN : file ../vk_helper.py line #939 6426 stp_strs[0] = ""; 6427 stringstream index_ss; 6428 if (pStruct->pMapEntries) { 6429 for (uint32_t i = 0; i < pStruct->mapEntryCount; i++) { 6430 index_ss.str(""); 6431 index_ss << i; 6432 // CODEGEN : file ../vk_helper.py line #980 6433 ss[0] << "0x" << &pStruct->pMapEntries[i]; 6434 tmp_str = vk_print_vkspecializationmapentry(&pStruct->pMapEntries[i], extra_indent); 6435 // CODEGEN : file ../vk_helper.py line #984 6436 stp_strs[0] += " " + prefix + "pMapEntries[" + index_ss.str() + "] (addr)\n" + tmp_str; 6437 // CODEGEN : file ../vk_helper.py line #1000 6438 ss[0].str(""); 6439 } 6440 } 6441 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6442 ss[0] << pStruct->mapEntryCount; 6443 // CODEGEN : file ../vk_helper.py line #1061 6444 ss[1] << "0x" << (void*)pStruct->pMapEntries; 6445 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6446 ss[2] << pStruct->dataSize; 6447 // CODEGEN : file ../vk_helper.py line #1070 6448 if (StreamControl::writeAddress) 6449 ss[3] << "0x" << pStruct->pData; 6450 else 6451 ss[3].str("address"); 6452 // CODEGEN : file ../vk_helper.py line #1113 6453 final_str = final_str + prefix + "mapEntryCount = " + ss[0].str() + "\n"; 6454 final_str = final_str + prefix + "pMapEntries = " + ss[1].str() + "\n"; 6455 final_str = final_str + prefix + "dataSize = " + ss[2].str() + "\n"; 6456 final_str = final_str + prefix + "pData = " + ss[3].str() + "\n"; 6457 final_str = final_str + stp_strs[0]; 6458 return final_str; 6459 } 6460 // CODEGEN : file ../vk_helper.py line #907 6461 std::string vk_print_vkspecializationmapentry(const VkSpecializationMapEntry* pStruct, const std::string prefix) 6462 { 6463 // CODEGEN : file ../vk_helper.py line #913 6464 using namespace StreamControl; 6465 using namespace std; 6466 string final_str; 6467 string tmp_str; 6468 string extra_indent = " " + prefix; 6469 stringstream ss[3]; 6470 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 6471 ss[0] << "0x" << pStruct->constantID; 6472 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 6473 ss[1] << "0x" << pStruct->offset; 6474 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6475 ss[2] << pStruct->size; 6476 // CODEGEN : file ../vk_helper.py line #1113 6477 final_str = final_str + prefix + "constantID = " + ss[0].str() + "\n"; 6478 final_str = final_str + prefix + "offset = " + ss[1].str() + "\n"; 6479 final_str = final_str + prefix + "size = " + ss[2].str() + "\n"; 6480 return final_str; 6481 } 6482 // CODEGEN : file ../vk_helper.py line #907 6483 std::string vk_print_vkstencilopstate(const VkStencilOpState* pStruct, const std::string prefix) 6484 { 6485 // CODEGEN : file ../vk_helper.py line #913 6486 using namespace StreamControl; 6487 using namespace std; 6488 string final_str; 6489 string tmp_str; 6490 string extra_indent = " " + prefix; 6491 stringstream ss[3]; 6492 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 6493 ss[0] << "0x" << pStruct->compareMask; 6494 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 6495 ss[1] << "0x" << pStruct->writeMask; 6496 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6497 ss[2] << pStruct->reference; 6498 // CODEGEN : file ../vk_helper.py line #1113 6499 final_str = final_str + prefix + "failOp = " + string_VkStencilOp(pStruct->failOp) + "\n"; 6500 final_str = final_str + prefix + "passOp = " + string_VkStencilOp(pStruct->passOp) + "\n"; 6501 final_str = final_str + prefix + "depthFailOp = " + string_VkStencilOp(pStruct->depthFailOp) + "\n"; 6502 final_str = final_str + prefix + "compareOp = " + string_VkCompareOp(pStruct->compareOp) + "\n"; 6503 final_str = final_str + prefix + "compareMask = " + ss[0].str() + "\n"; 6504 final_str = final_str + prefix + "writeMask = " + ss[1].str() + "\n"; 6505 final_str = final_str + prefix + "reference = " + ss[2].str() + "\n"; 6506 return final_str; 6507 } 6508 // CODEGEN : file ../vk_helper.py line #907 6509 std::string vk_print_vksubmitinfo(const VkSubmitInfo* pStruct, const std::string prefix) 6510 { 6511 // CODEGEN : file ../vk_helper.py line #913 6512 using namespace StreamControl; 6513 using namespace std; 6514 string final_str; 6515 string tmp_str; 6516 string extra_indent = " " + prefix; 6517 stringstream ss[8]; 6518 string stp_strs[4]; 6519 // CODEGEN : file ../vk_helper.py line #1012 6520 if (pStruct->pNext) { 6521 // CODEGEN : file ../vk_helper.py line #1016 6522 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 6523 ss[0] << "0x" << &pStruct->pNext; 6524 // CODEGEN : file ../vk_helper.py line #1028 6525 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 6526 ss[0].str(""); 6527 } 6528 else 6529 stp_strs[0] = ""; 6530 // CODEGEN : file ../vk_helper.py line #932 6531 // CODEGEN : file ../vk_helper.py line #934 6532 // CODEGEN : file ../vk_helper.py line #939 6533 stp_strs[1] = ""; 6534 stringstream index_ss; 6535 if (pStruct->pWaitSemaphores) { 6536 for (uint32_t i = 0; i < pStruct->waitSemaphoreCount; i++) { 6537 index_ss.str(""); 6538 index_ss << i; 6539 // CODEGEN : file ../vk_helper.py line #990 6540 ss[1] << "0x" << pStruct->pWaitSemaphores[i]; 6541 stp_strs[1] += " " + prefix + "pWaitSemaphores[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 6542 // CODEGEN : file ../vk_helper.py line #1000 6543 ss[1].str(""); 6544 } 6545 } 6546 // CODEGEN : file ../vk_helper.py line #932 6547 // CODEGEN : file ../vk_helper.py line #934 6548 // CODEGEN : file ../vk_helper.py line #939 6549 stp_strs[2] = ""; 6550 if (pStruct->pCommandBuffers) { 6551 for (uint32_t i = 0; i < pStruct->commandBufferCount; i++) { 6552 index_ss.str(""); 6553 index_ss << i; 6554 // CODEGEN : file ../vk_helper.py line #990 6555 ss[2] << "0x" << pStruct->pCommandBuffers[i]; 6556 stp_strs[2] += " " + prefix + "pCommandBuffers[" + index_ss.str() + "].handle = " + ss[2].str() + "\n"; 6557 // CODEGEN : file ../vk_helper.py line #1000 6558 ss[2].str(""); 6559 } 6560 } 6561 // CODEGEN : file ../vk_helper.py line #932 6562 // CODEGEN : file ../vk_helper.py line #934 6563 // CODEGEN : file ../vk_helper.py line #939 6564 stp_strs[3] = ""; 6565 if (pStruct->pSignalSemaphores) { 6566 for (uint32_t i = 0; i < pStruct->signalSemaphoreCount; i++) { 6567 index_ss.str(""); 6568 index_ss << i; 6569 // CODEGEN : file ../vk_helper.py line #990 6570 ss[3] << "0x" << pStruct->pSignalSemaphores[i]; 6571 stp_strs[3] += " " + prefix + "pSignalSemaphores[" + index_ss.str() + "].handle = " + ss[3].str() + "\n"; 6572 // CODEGEN : file ../vk_helper.py line #1000 6573 ss[3].str(""); 6574 } 6575 } 6576 // CODEGEN : file ../vk_helper.py line #1070 6577 if (StreamControl::writeAddress) 6578 ss[0] << "0x" << pStruct->pNext; 6579 else 6580 ss[0].str("address"); 6581 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6582 ss[1] << pStruct->waitSemaphoreCount; 6583 // CODEGEN : file ../vk_helper.py line #1061 6584 ss[2] << "0x" << (void*)pStruct->pWaitSemaphores; 6585 // CODEGEN : file ../vk_helper.py line #1086 6586 ss[3] << "0x" << pStruct->pWaitDstStageMask; 6587 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 6588 ss[4] << "0x" << pStruct->commandBufferCount; 6589 // CODEGEN : file ../vk_helper.py line #1061 6590 ss[5] << "0x" << (void*)pStruct->pCommandBuffers; 6591 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6592 ss[6] << pStruct->signalSemaphoreCount; 6593 // CODEGEN : file ../vk_helper.py line #1061 6594 ss[7] << "0x" << (void*)pStruct->pSignalSemaphores; 6595 // CODEGEN : file ../vk_helper.py line #1113 6596 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 6597 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 6598 final_str = final_str + prefix + "waitSemaphoreCount = " + ss[1].str() + "\n"; 6599 final_str = final_str + prefix + "pWaitSemaphores = " + ss[2].str() + "\n"; 6600 final_str = final_str + prefix + "pWaitDstStageMask = " + ss[3].str() + "\n"; 6601 final_str = final_str + prefix + "commandBufferCount = " + ss[4].str() + "\n"; 6602 final_str = final_str + prefix + "pCommandBuffers = " + ss[5].str() + "\n"; 6603 final_str = final_str + prefix + "signalSemaphoreCount = " + ss[6].str() + "\n"; 6604 final_str = final_str + prefix + "pSignalSemaphores = " + ss[7].str() + "\n"; 6605 final_str = final_str + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 6606 return final_str; 6607 } 6608 // CODEGEN : file ../vk_helper.py line #907 6609 std::string vk_print_vksubpassdependency(const VkSubpassDependency* pStruct, const std::string prefix) 6610 { 6611 // CODEGEN : file ../vk_helper.py line #913 6612 using namespace StreamControl; 6613 using namespace std; 6614 string final_str; 6615 string tmp_str; 6616 string extra_indent = " " + prefix; 6617 stringstream ss[7]; 6618 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6619 ss[0] << pStruct->srcSubpass; 6620 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6621 ss[1] << pStruct->dstSubpass; 6622 // CODEGEN : file ../vk_helper.py line #1086 6623 ss[2] << "0x" << pStruct->srcStageMask; 6624 // CODEGEN : file ../vk_helper.py line #1086 6625 ss[3] << "0x" << pStruct->dstStageMask; 6626 // CODEGEN : file ../vk_helper.py line #1086 6627 ss[4] << "0x" << pStruct->srcAccessMask; 6628 // CODEGEN : file ../vk_helper.py line #1086 6629 ss[5] << "0x" << pStruct->dstAccessMask; 6630 // CODEGEN : file ../vk_helper.py line #1086 6631 ss[6] << "0x" << pStruct->dependencyFlags; 6632 // CODEGEN : file ../vk_helper.py line #1113 6633 final_str = final_str + prefix + "srcSubpass = " + ss[0].str() + "\n"; 6634 final_str = final_str + prefix + "dstSubpass = " + ss[1].str() + "\n"; 6635 final_str = final_str + prefix + "srcStageMask = " + ss[2].str() + "\n"; 6636 final_str = final_str + prefix + "dstStageMask = " + ss[3].str() + "\n"; 6637 final_str = final_str + prefix + "srcAccessMask = " + ss[4].str() + "\n"; 6638 final_str = final_str + prefix + "dstAccessMask = " + ss[5].str() + "\n"; 6639 final_str = final_str + prefix + "dependencyFlags = " + ss[6].str() + "\n"; 6640 return final_str; 6641 } 6642 // CODEGEN : file ../vk_helper.py line #907 6643 std::string vk_print_vksubpassdescription(const VkSubpassDescription* pStruct, const std::string prefix) 6644 { 6645 // CODEGEN : file ../vk_helper.py line #913 6646 using namespace StreamControl; 6647 using namespace std; 6648 string final_str; 6649 string tmp_str; 6650 string extra_indent = " " + prefix; 6651 stringstream ss[9]; 6652 string stp_strs[5]; 6653 // CODEGEN : file ../vk_helper.py line #932 6654 // CODEGEN : file ../vk_helper.py line #934 6655 // CODEGEN : file ../vk_helper.py line #939 6656 stp_strs[0] = ""; 6657 stringstream index_ss; 6658 if (pStruct->pInputAttachments) { 6659 for (uint32_t i = 0; i < pStruct->inputAttachmentCount; i++) { 6660 index_ss.str(""); 6661 index_ss << i; 6662 // CODEGEN : file ../vk_helper.py line #980 6663 ss[0] << "0x" << &pStruct->pInputAttachments[i]; 6664 tmp_str = vk_print_vkattachmentreference(&pStruct->pInputAttachments[i], extra_indent); 6665 // CODEGEN : file ../vk_helper.py line #984 6666 stp_strs[0] += " " + prefix + "pInputAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 6667 // CODEGEN : file ../vk_helper.py line #1000 6668 ss[0].str(""); 6669 } 6670 } 6671 // CODEGEN : file ../vk_helper.py line #932 6672 // CODEGEN : file ../vk_helper.py line #934 6673 // CODEGEN : file ../vk_helper.py line #939 6674 stp_strs[1] = ""; 6675 if (pStruct->pColorAttachments) { 6676 for (uint32_t i = 0; i < pStruct->colorAttachmentCount; i++) { 6677 index_ss.str(""); 6678 index_ss << i; 6679 // CODEGEN : file ../vk_helper.py line #980 6680 ss[1] << "0x" << &pStruct->pColorAttachments[i]; 6681 tmp_str = vk_print_vkattachmentreference(&pStruct->pColorAttachments[i], extra_indent); 6682 // CODEGEN : file ../vk_helper.py line #984 6683 stp_strs[1] += " " + prefix + "pColorAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 6684 // CODEGEN : file ../vk_helper.py line #1000 6685 ss[1].str(""); 6686 } 6687 } 6688 // CODEGEN : file ../vk_helper.py line #932 6689 // CODEGEN : file ../vk_helper.py line #934 6690 // CODEGEN : file ../vk_helper.py line #939 6691 stp_strs[2] = ""; 6692 if (pStruct->pResolveAttachments) { 6693 for (uint32_t i = 0; i < pStruct->colorAttachmentCount; i++) { 6694 index_ss.str(""); 6695 index_ss << i; 6696 // CODEGEN : file ../vk_helper.py line #980 6697 ss[2] << "0x" << &pStruct->pResolveAttachments[i]; 6698 tmp_str = vk_print_vkattachmentreference(&pStruct->pResolveAttachments[i], extra_indent); 6699 // CODEGEN : file ../vk_helper.py line #984 6700 stp_strs[2] += " " + prefix + "pResolveAttachments[" + index_ss.str() + "] (addr)\n" + tmp_str; 6701 // CODEGEN : file ../vk_helper.py line #1000 6702 ss[2].str(""); 6703 } 6704 } 6705 // CODEGEN : file ../vk_helper.py line #1012 6706 if (pStruct->pDepthStencilAttachment) { 6707 // CODEGEN : file ../vk_helper.py line #1024 6708 tmp_str = vk_print_vkattachmentreference(pStruct->pDepthStencilAttachment, extra_indent); 6709 ss[3] << "0x" << &pStruct->pDepthStencilAttachment; 6710 // CODEGEN : file ../vk_helper.py line #1028 6711 stp_strs[3] = " " + prefix + "pDepthStencilAttachment (addr)\n" + tmp_str; 6712 ss[3].str(""); 6713 } 6714 else 6715 stp_strs[3] = ""; 6716 // CODEGEN : file ../vk_helper.py line #932 6717 // CODEGEN : file ../vk_helper.py line #934 6718 // CODEGEN : file ../vk_helper.py line #939 6719 stp_strs[4] = ""; 6720 if (pStruct->pPreserveAttachments) { 6721 for (uint32_t i = 0; i < pStruct->preserveAttachmentCount; i++) { 6722 index_ss.str(""); 6723 index_ss << i; 6724 // CODEGEN : file ../vk_helper.py line #990 6725 ss[4] << "0x" << pStruct->pPreserveAttachments[i]; 6726 stp_strs[4] += " " + prefix + "pPreserveAttachments[" + index_ss.str() + "] = " + ss[4].str() + "\n"; 6727 // CODEGEN : file ../vk_helper.py line #1000 6728 ss[4].str(""); 6729 } 6730 } 6731 // CODEGEN : file ../vk_helper.py line #1086 6732 ss[0] << "0x" << pStruct->flags; 6733 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6734 ss[1] << pStruct->inputAttachmentCount; 6735 // CODEGEN : file ../vk_helper.py line #1061 6736 ss[2] << "0x" << (void*)pStruct->pInputAttachments; 6737 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6738 ss[3] << pStruct->colorAttachmentCount; 6739 // CODEGEN : file ../vk_helper.py line #1061 6740 ss[4] << "0x" << (void*)pStruct->pColorAttachments; 6741 // CODEGEN : file ../vk_helper.py line #1061 6742 ss[5] << "0x" << (void*)pStruct->pResolveAttachments; 6743 // CODEGEN : file ../vk_helper.py line #1086 6744 ss[6] << "0x" << pStruct->pDepthStencilAttachment; 6745 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6746 ss[7] << pStruct->preserveAttachmentCount; 6747 // CODEGEN : file ../vk_helper.py line #1061 6748 ss[8] << "0x" << (void*)pStruct->pPreserveAttachments; 6749 // CODEGEN : file ../vk_helper.py line #1113 6750 final_str = final_str + prefix + "flags = " + ss[0].str() + "\n"; 6751 final_str = final_str + prefix + "pipelineBindPoint = " + string_VkPipelineBindPoint(pStruct->pipelineBindPoint) + "\n"; 6752 final_str = final_str + prefix + "inputAttachmentCount = " + ss[1].str() + "\n"; 6753 final_str = final_str + prefix + "pInputAttachments = " + ss[2].str() + "\n"; 6754 final_str = final_str + prefix + "colorAttachmentCount = " + ss[3].str() + "\n"; 6755 final_str = final_str + prefix + "pColorAttachments = " + ss[4].str() + "\n"; 6756 final_str = final_str + prefix + "pResolveAttachments = " + ss[5].str() + "\n"; 6757 final_str = final_str + prefix + "pDepthStencilAttachment = " + ss[6].str() + "\n"; 6758 final_str = final_str + prefix + "preserveAttachmentCount = " + ss[7].str() + "\n"; 6759 final_str = final_str + prefix + "pPreserveAttachments = " + ss[8].str() + "\n"; 6760 final_str = final_str + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 6761 return final_str; 6762 } 6763 // CODEGEN : file ../vk_helper.py line #907 6764 std::string vk_print_vksubresourcelayout(const VkSubresourceLayout* pStruct, const std::string prefix) 6765 { 6766 // CODEGEN : file ../vk_helper.py line #913 6767 using namespace StreamControl; 6768 using namespace std; 6769 string final_str; 6770 string tmp_str; 6771 string extra_indent = " " + prefix; 6772 stringstream ss[5]; 6773 // CODEGEN : file ../vk_helper.py line #1086 6774 ss[0] << "0x" << pStruct->offset; 6775 // CODEGEN : file ../vk_helper.py line #1086 6776 ss[1] << "0x" << pStruct->size; 6777 // CODEGEN : file ../vk_helper.py line #1086 6778 ss[2] << "0x" << pStruct->rowPitch; 6779 // CODEGEN : file ../vk_helper.py line #1086 6780 ss[3] << "0x" << pStruct->arrayPitch; 6781 // CODEGEN : file ../vk_helper.py line #1086 6782 ss[4] << "0x" << pStruct->depthPitch; 6783 // CODEGEN : file ../vk_helper.py line #1113 6784 final_str = final_str + prefix + "offset = " + ss[0].str() + "\n"; 6785 final_str = final_str + prefix + "size = " + ss[1].str() + "\n"; 6786 final_str = final_str + prefix + "rowPitch = " + ss[2].str() + "\n"; 6787 final_str = final_str + prefix + "arrayPitch = " + ss[3].str() + "\n"; 6788 final_str = final_str + prefix + "depthPitch = " + ss[4].str() + "\n"; 6789 return final_str; 6790 } 6791 // CODEGEN : file ../vk_helper.py line #907 6792 std::string vk_print_vksurfacecapabilitieskhr(const VkSurfaceCapabilitiesKHR* pStruct, const std::string prefix) 6793 { 6794 // CODEGEN : file ../vk_helper.py line #913 6795 using namespace StreamControl; 6796 using namespace std; 6797 string final_str; 6798 string tmp_str; 6799 string extra_indent = " " + prefix; 6800 stringstream ss[9]; 6801 string stp_strs[3]; 6802 // CODEGEN : file ../vk_helper.py line #1038 6803 tmp_str = vk_print_vkextent2d(&pStruct->currentExtent, extra_indent); 6804 ss[0] << "0x" << &pStruct->currentExtent; 6805 stp_strs[0] = " " + prefix + "currentExtent (addr)\n" + tmp_str; 6806 // CODEGEN : file ../vk_helper.py line #1043 6807 ss[0].str(""); 6808 // CODEGEN : file ../vk_helper.py line #1038 6809 tmp_str = vk_print_vkextent2d(&pStruct->minImageExtent, extra_indent); 6810 ss[1] << "0x" << &pStruct->minImageExtent; 6811 stp_strs[1] = " " + prefix + "minImageExtent (addr)\n" + tmp_str; 6812 // CODEGEN : file ../vk_helper.py line #1043 6813 ss[1].str(""); 6814 // CODEGEN : file ../vk_helper.py line #1038 6815 tmp_str = vk_print_vkextent2d(&pStruct->maxImageExtent, extra_indent); 6816 ss[2] << "0x" << &pStruct->maxImageExtent; 6817 stp_strs[2] = " " + prefix + "maxImageExtent (addr)\n" + tmp_str; 6818 // CODEGEN : file ../vk_helper.py line #1043 6819 ss[2].str(""); 6820 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6821 ss[0] << pStruct->minImageCount; 6822 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6823 ss[1] << pStruct->maxImageCount; 6824 // CODEGEN : file ../vk_helper.py line #1055 6825 ss[2].str("addr"); 6826 // CODEGEN : file ../vk_helper.py line #1055 6827 ss[3].str("addr"); 6828 // CODEGEN : file ../vk_helper.py line #1055 6829 ss[4].str("addr"); 6830 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6831 ss[5] << pStruct->maxImageArrayLayers; 6832 // CODEGEN : file ../vk_helper.py line #1086 6833 ss[6] << "0x" << pStruct->supportedTransforms; 6834 // CODEGEN : file ../vk_helper.py line #1086 6835 ss[7] << "0x" << pStruct->supportedCompositeAlpha; 6836 // CODEGEN : file ../vk_helper.py line #1086 6837 ss[8] << "0x" << pStruct->supportedUsageFlags; 6838 // CODEGEN : file ../vk_helper.py line #1113 6839 final_str = final_str + prefix + "minImageCount = " + ss[0].str() + "\n"; 6840 final_str = final_str + prefix + "maxImageCount = " + ss[1].str() + "\n"; 6841 final_str = final_str + prefix + "currentExtent = " + ss[2].str() + "\n"; 6842 final_str = final_str + prefix + "minImageExtent = " + ss[3].str() + "\n"; 6843 final_str = final_str + prefix + "maxImageExtent = " + ss[4].str() + "\n"; 6844 final_str = final_str + prefix + "maxImageArrayLayers = " + ss[5].str() + "\n"; 6845 final_str = final_str + prefix + "supportedTransforms = " + ss[6].str() + "\n"; 6846 final_str = final_str + prefix + "currentTransform = " + string_VkSurfaceTransformFlagBitsKHR(pStruct->currentTransform) + "\n"; 6847 final_str = final_str + prefix + "supportedCompositeAlpha = " + ss[7].str() + "\n"; 6848 final_str = final_str + prefix + "supportedUsageFlags = " + ss[8].str() + "\n"; 6849 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 6850 return final_str; 6851 } 6852 // CODEGEN : file ../vk_helper.py line #907 6853 std::string vk_print_vksurfaceformatkhr(const VkSurfaceFormatKHR* pStruct, const std::string prefix) 6854 { 6855 // CODEGEN : file ../vk_helper.py line #913 6856 using namespace StreamControl; 6857 using namespace std; 6858 string final_str; 6859 string tmp_str; 6860 string extra_indent = " " + prefix; 6861 // CODEGEN : file ../vk_helper.py line #1113 6862 final_str = final_str + prefix + "format = " + string_VkFormat(pStruct->format) + "\n"; 6863 final_str = final_str + prefix + "colorSpace = " + string_VkColorSpaceKHR(pStruct->colorSpace) + "\n"; 6864 return final_str; 6865 } 6866 // CODEGEN : file ../vk_helper.py line #907 6867 std::string vk_print_vkswapchaincreateinfokhr(const VkSwapchainCreateInfoKHR* pStruct, const std::string prefix) 6868 { 6869 // CODEGEN : file ../vk_helper.py line #913 6870 using namespace StreamControl; 6871 using namespace std; 6872 string final_str; 6873 string tmp_str; 6874 string extra_indent = " " + prefix; 6875 stringstream ss[11]; 6876 string stp_strs[3]; 6877 // CODEGEN : file ../vk_helper.py line #1012 6878 if (pStruct->pNext) { 6879 // CODEGEN : file ../vk_helper.py line #1016 6880 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 6881 ss[0] << "0x" << &pStruct->pNext; 6882 // CODEGEN : file ../vk_helper.py line #1028 6883 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 6884 ss[0].str(""); 6885 } 6886 else 6887 stp_strs[0] = ""; 6888 // CODEGEN : file ../vk_helper.py line #1038 6889 tmp_str = vk_print_vkextent2d(&pStruct->imageExtent, extra_indent); 6890 ss[1] << "0x" << &pStruct->imageExtent; 6891 stp_strs[1] = " " + prefix + "imageExtent (addr)\n" + tmp_str; 6892 // CODEGEN : file ../vk_helper.py line #1043 6893 ss[1].str(""); 6894 // CODEGEN : file ../vk_helper.py line #932 6895 // CODEGEN : file ../vk_helper.py line #934 6896 // CODEGEN : file ../vk_helper.py line #939 6897 stp_strs[2] = ""; 6898 stringstream index_ss; 6899 if (pStruct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) { 6900 if (pStruct->pQueueFamilyIndices) { 6901 for (uint32_t i = 0; i < pStruct->queueFamilyIndexCount; i++) { 6902 index_ss.str(""); 6903 index_ss << i; 6904 // CODEGEN : file ../vk_helper.py line #990 6905 ss[2] << "0x" << pStruct->pQueueFamilyIndices[i]; 6906 stp_strs[2] += " " + prefix + "pQueueFamilyIndices[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 6907 // CODEGEN : file ../vk_helper.py line #1000 6908 ss[2].str(""); 6909 } 6910 } 6911 } 6912 // CODEGEN : file ../vk_helper.py line #1070 6913 if (StreamControl::writeAddress) 6914 ss[0] << "0x" << pStruct->pNext; 6915 else 6916 ss[0].str("address"); 6917 // CODEGEN : file ../vk_helper.py line #1086 6918 ss[1] << "0x" << pStruct->flags; 6919 // CODEGEN : file ../vk_helper.py line #1086 6920 ss[2] << "0x" << pStruct->surface; 6921 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6922 ss[3] << pStruct->minImageCount; 6923 // CODEGEN : file ../vk_helper.py line #1055 6924 ss[4].str("addr"); 6925 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6926 ss[5] << pStruct->imageArrayLayers; 6927 // CODEGEN : file ../vk_helper.py line #1086 6928 ss[6] << "0x" << pStruct->imageUsage; 6929 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6930 ss[7] << pStruct->queueFamilyIndexCount; 6931 // CODEGEN : file ../vk_helper.py line #1061 6932 ss[8] << "0x" << (void*)pStruct->pQueueFamilyIndices; 6933 // CODEGEN : file ../vk_helper.py line #1064 6934 ss[9].str(pStruct->clipped ? "TRUE" : "FALSE"); 6935 // CODEGEN : file ../vk_helper.py line #1086 6936 ss[10] << "0x" << pStruct->oldSwapchain; 6937 // CODEGEN : file ../vk_helper.py line #1113 6938 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 6939 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 6940 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 6941 final_str = final_str + prefix + "surface = " + ss[2].str() + "\n"; 6942 final_str = final_str + prefix + "minImageCount = " + ss[3].str() + "\n"; 6943 final_str = final_str + prefix + "imageFormat = " + string_VkFormat(pStruct->imageFormat) + "\n"; 6944 final_str = final_str + prefix + "imageColorSpace = " + string_VkColorSpaceKHR(pStruct->imageColorSpace) + "\n"; 6945 final_str = final_str + prefix + "imageExtent = " + ss[4].str() + "\n"; 6946 final_str = final_str + prefix + "imageArrayLayers = " + ss[5].str() + "\n"; 6947 final_str = final_str + prefix + "imageUsage = " + ss[6].str() + "\n"; 6948 final_str = final_str + prefix + "imageSharingMode = " + string_VkSharingMode(pStruct->imageSharingMode) + "\n"; 6949 final_str = final_str + prefix + "queueFamilyIndexCount = " + ss[7].str() + "\n"; 6950 final_str = final_str + prefix + "pQueueFamilyIndices = " + ss[8].str() + "\n"; 6951 final_str = final_str + prefix + "preTransform = " + string_VkSurfaceTransformFlagBitsKHR(pStruct->preTransform) + "\n"; 6952 final_str = final_str + prefix + "compositeAlpha = " + string_VkCompositeAlphaFlagBitsKHR(pStruct->compositeAlpha) + "\n"; 6953 final_str = final_str + prefix + "presentMode = " + string_VkPresentModeKHR(pStruct->presentMode) + "\n"; 6954 final_str = final_str + prefix + "clipped = " + ss[9].str() + "\n"; 6955 final_str = final_str + prefix + "oldSwapchain = " + ss[10].str() + "\n"; 6956 final_str = final_str + stp_strs[2] + stp_strs[1] + stp_strs[0]; 6957 return final_str; 6958 } 6959 // CODEGEN : file ../vk_helper.py line #907 6960 std::string vk_print_vkvalidationflagsext(const VkValidationFlagsEXT* pStruct, const std::string prefix) 6961 { 6962 // CODEGEN : file ../vk_helper.py line #913 6963 using namespace StreamControl; 6964 using namespace std; 6965 string final_str; 6966 string tmp_str; 6967 string extra_indent = " " + prefix; 6968 stringstream ss[3]; 6969 string stp_strs[1]; 6970 // CODEGEN : file ../vk_helper.py line #1012 6971 if (pStruct->pNext) { 6972 // CODEGEN : file ../vk_helper.py line #1016 6973 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 6974 ss[0] << "0x" << &pStruct->pNext; 6975 // CODEGEN : file ../vk_helper.py line #1028 6976 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 6977 ss[0].str(""); 6978 } 6979 else 6980 stp_strs[0] = ""; 6981 // CODEGEN : file ../vk_helper.py line #1070 6982 if (StreamControl::writeAddress) 6983 ss[0] << "0x" << pStruct->pNext; 6984 else 6985 ss[0].str("address"); 6986 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 6987 ss[1] << pStruct->disabledValidationCheckCount; 6988 // CODEGEN : file ../vk_helper.py line #1100 6989 if (pStruct->pDisabledValidationChecks) 6990 ss[2] << "0x" << pStruct->pDisabledValidationChecks << " (See individual array values below)"; 6991 else 6992 ss[2].str("NULL"); 6993 // CODEGEN : file ../vk_helper.py line #1113 6994 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 6995 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 6996 final_str = final_str + prefix + "disabledValidationCheckCount = " + ss[1].str() + "\n"; 6997 final_str = final_str + prefix + "pDisabledValidationChecks = " + ss[2].str() + "\n"; 6998 final_str = final_str + stp_strs[0]; 6999 return final_str; 7000 } 7001 // CODEGEN : file ../vk_helper.py line #907 7002 std::string vk_print_vkvertexinputattributedescription(const VkVertexInputAttributeDescription* pStruct, const std::string prefix) 7003 { 7004 // CODEGEN : file ../vk_helper.py line #913 7005 using namespace StreamControl; 7006 using namespace std; 7007 string final_str; 7008 string tmp_str; 7009 string extra_indent = " " + prefix; 7010 stringstream ss[3]; 7011 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7012 ss[0] << pStruct->location; 7013 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7014 ss[1] << pStruct->binding; 7015 // CODEGEN : file ../vk_helper.py line #1090: NB: Edit here to choose hex vs dec output by variable name 7016 ss[2] << "0x" << pStruct->offset; 7017 // CODEGEN : file ../vk_helper.py line #1113 7018 final_str = final_str + prefix + "location = " + ss[0].str() + "\n"; 7019 final_str = final_str + prefix + "binding = " + ss[1].str() + "\n"; 7020 final_str = final_str + prefix + "format = " + string_VkFormat(pStruct->format) + "\n"; 7021 final_str = final_str + prefix + "offset = " + ss[2].str() + "\n"; 7022 return final_str; 7023 } 7024 // CODEGEN : file ../vk_helper.py line #907 7025 std::string vk_print_vkvertexinputbindingdescription(const VkVertexInputBindingDescription* pStruct, const std::string prefix) 7026 { 7027 // CODEGEN : file ../vk_helper.py line #913 7028 using namespace StreamControl; 7029 using namespace std; 7030 string final_str; 7031 string tmp_str; 7032 string extra_indent = " " + prefix; 7033 stringstream ss[2]; 7034 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7035 ss[0] << pStruct->binding; 7036 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7037 ss[1] << pStruct->stride; 7038 // CODEGEN : file ../vk_helper.py line #1113 7039 final_str = final_str + prefix + "binding = " + ss[0].str() + "\n"; 7040 final_str = final_str + prefix + "stride = " + ss[1].str() + "\n"; 7041 final_str = final_str + prefix + "inputRate = " + string_VkVertexInputRate(pStruct->inputRate) + "\n"; 7042 return final_str; 7043 } 7044 // CODEGEN : file ../vk_helper.py line #907 7045 std::string vk_print_vkviewport(const VkViewport* pStruct, const std::string prefix) 7046 { 7047 // CODEGEN : file ../vk_helper.py line #913 7048 using namespace StreamControl; 7049 using namespace std; 7050 string final_str; 7051 string tmp_str; 7052 string extra_indent = " " + prefix; 7053 stringstream ss[6]; 7054 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7055 ss[0] << pStruct->x; 7056 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7057 ss[1] << pStruct->y; 7058 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7059 ss[2] << pStruct->width; 7060 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7061 ss[3] << pStruct->height; 7062 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7063 ss[4] << pStruct->minDepth; 7064 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7065 ss[5] << pStruct->maxDepth; 7066 // CODEGEN : file ../vk_helper.py line #1113 7067 final_str = final_str + prefix + "x = " + ss[0].str() + "\n"; 7068 final_str = final_str + prefix + "y = " + ss[1].str() + "\n"; 7069 final_str = final_str + prefix + "width = " + ss[2].str() + "\n"; 7070 final_str = final_str + prefix + "height = " + ss[3].str() + "\n"; 7071 final_str = final_str + prefix + "minDepth = " + ss[4].str() + "\n"; 7072 final_str = final_str + prefix + "maxDepth = " + ss[5].str() + "\n"; 7073 return final_str; 7074 } 7075 // CODEGEN : file ../vk_helper.py line #907 7076 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 7077 std::string vk_print_vkwaylandsurfacecreateinfokhr(const VkWaylandSurfaceCreateInfoKHR* pStruct, const std::string prefix) 7078 { 7079 // CODEGEN : file ../vk_helper.py line #913 7080 using namespace StreamControl; 7081 using namespace std; 7082 string final_str; 7083 string tmp_str; 7084 string extra_indent = " " + prefix; 7085 stringstream ss[4]; 7086 string stp_strs[1]; 7087 // CODEGEN : file ../vk_helper.py line #1012 7088 if (pStruct->pNext) { 7089 // CODEGEN : file ../vk_helper.py line #1016 7090 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 7091 ss[0] << "0x" << &pStruct->pNext; 7092 // CODEGEN : file ../vk_helper.py line #1028 7093 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 7094 ss[0].str(""); 7095 } 7096 else 7097 stp_strs[0] = ""; 7098 // CODEGEN : file ../vk_helper.py line #1070 7099 if (StreamControl::writeAddress) 7100 ss[0] << "0x" << pStruct->pNext; 7101 else 7102 ss[0].str("address"); 7103 // CODEGEN : file ../vk_helper.py line #1086 7104 ss[1] << "0x" << pStruct->flags; 7105 // CODEGEN : file ../vk_helper.py line #1086 7106 ss[2] << "0x" << pStruct->display; 7107 // CODEGEN : file ../vk_helper.py line #1086 7108 ss[3] << "0x" << pStruct->surface; 7109 // CODEGEN : file ../vk_helper.py line #1113 7110 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 7111 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 7112 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 7113 final_str = final_str + prefix + "display = " + ss[2].str() + "\n"; 7114 final_str = final_str + prefix + "surface = " + ss[3].str() + "\n"; 7115 final_str = final_str + stp_strs[0]; 7116 return final_str; 7117 } 7118 #endif //VK_USE_PLATFORM_WAYLAND_KHR 7119 // CODEGEN : file ../vk_helper.py line #907 7120 #ifdef VK_USE_PLATFORM_WIN32_KHR 7121 std::string vk_print_vkwin32keyedmutexacquirereleaseinfonv(const VkWin32KeyedMutexAcquireReleaseInfoNV* pStruct, const std::string prefix) 7122 { 7123 // CODEGEN : file ../vk_helper.py line #913 7124 using namespace StreamControl; 7125 using namespace std; 7126 string final_str; 7127 string tmp_str; 7128 string extra_indent = " " + prefix; 7129 stringstream ss[8]; 7130 string stp_strs[6]; 7131 // CODEGEN : file ../vk_helper.py line #1012 7132 if (pStruct->pNext) { 7133 // CODEGEN : file ../vk_helper.py line #1016 7134 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 7135 ss[0] << "0x" << &pStruct->pNext; 7136 // CODEGEN : file ../vk_helper.py line #1028 7137 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 7138 ss[0].str(""); 7139 } 7140 else 7141 stp_strs[0] = ""; 7142 // CODEGEN : file ../vk_helper.py line #932 7143 // CODEGEN : file ../vk_helper.py line #934 7144 // CODEGEN : file ../vk_helper.py line #939 7145 stp_strs[1] = ""; 7146 stringstream index_ss; 7147 if (pStruct->pAcquireSyncs) { 7148 for (uint32_t i = 0; i < pStruct->acquireCount; i++) { 7149 index_ss.str(""); 7150 index_ss << i; 7151 // CODEGEN : file ../vk_helper.py line #990 7152 ss[1] << "0x" << pStruct->pAcquireSyncs[i]; 7153 stp_strs[1] += " " + prefix + "pAcquireSyncs[" + index_ss.str() + "].handle = " + ss[1].str() + "\n"; 7154 // CODEGEN : file ../vk_helper.py line #1000 7155 ss[1].str(""); 7156 } 7157 } 7158 // CODEGEN : file ../vk_helper.py line #932 7159 // CODEGEN : file ../vk_helper.py line #934 7160 // CODEGEN : file ../vk_helper.py line #939 7161 stp_strs[2] = ""; 7162 if (pStruct->pAcquireKeys) { 7163 for (uint32_t i = 0; i < pStruct->acquireCount; i++) { 7164 index_ss.str(""); 7165 index_ss << i; 7166 // CODEGEN : file ../vk_helper.py line #990 7167 ss[2] << "0x" << pStruct->pAcquireKeys[i]; 7168 stp_strs[2] += " " + prefix + "pAcquireKeys[" + index_ss.str() + "] = " + ss[2].str() + "\n"; 7169 // CODEGEN : file ../vk_helper.py line #1000 7170 ss[2].str(""); 7171 } 7172 } 7173 // CODEGEN : file ../vk_helper.py line #932 7174 // CODEGEN : file ../vk_helper.py line #934 7175 // CODEGEN : file ../vk_helper.py line #939 7176 stp_strs[3] = ""; 7177 if (pStruct->pAcquireTimeoutMilliseconds) { 7178 for (uint32_t i = 0; i < pStruct->acquireCount; i++) { 7179 index_ss.str(""); 7180 index_ss << i; 7181 // CODEGEN : file ../vk_helper.py line #990 7182 ss[3] << "0x" << pStruct->pAcquireTimeoutMilliseconds[i]; 7183 stp_strs[3] += " " + prefix + "pAcquireTimeoutMilliseconds[" + index_ss.str() + "] = " + ss[3].str() + "\n"; 7184 // CODEGEN : file ../vk_helper.py line #1000 7185 ss[3].str(""); 7186 } 7187 } 7188 // CODEGEN : file ../vk_helper.py line #932 7189 // CODEGEN : file ../vk_helper.py line #934 7190 // CODEGEN : file ../vk_helper.py line #939 7191 stp_strs[4] = ""; 7192 if (pStruct->pReleaseSyncs) { 7193 for (uint32_t i = 0; i < pStruct->releaseCount; i++) { 7194 index_ss.str(""); 7195 index_ss << i; 7196 // CODEGEN : file ../vk_helper.py line #990 7197 ss[4] << "0x" << pStruct->pReleaseSyncs[i]; 7198 stp_strs[4] += " " + prefix + "pReleaseSyncs[" + index_ss.str() + "].handle = " + ss[4].str() + "\n"; 7199 // CODEGEN : file ../vk_helper.py line #1000 7200 ss[4].str(""); 7201 } 7202 } 7203 // CODEGEN : file ../vk_helper.py line #932 7204 // CODEGEN : file ../vk_helper.py line #934 7205 // CODEGEN : file ../vk_helper.py line #939 7206 stp_strs[5] = ""; 7207 if (pStruct->pReleaseKeys) { 7208 for (uint32_t i = 0; i < pStruct->releaseCount; i++) { 7209 index_ss.str(""); 7210 index_ss << i; 7211 // CODEGEN : file ../vk_helper.py line #990 7212 ss[5] << "0x" << pStruct->pReleaseKeys[i]; 7213 stp_strs[5] += " " + prefix + "pReleaseKeys[" + index_ss.str() + "] = " + ss[5].str() + "\n"; 7214 // CODEGEN : file ../vk_helper.py line #1000 7215 ss[5].str(""); 7216 } 7217 } 7218 // CODEGEN : file ../vk_helper.py line #1070 7219 if (StreamControl::writeAddress) 7220 ss[0] << "0x" << pStruct->pNext; 7221 else 7222 ss[0].str("address"); 7223 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7224 ss[1] << pStruct->acquireCount; 7225 // CODEGEN : file ../vk_helper.py line #1061 7226 ss[2] << "0x" << (void*)pStruct->pAcquireSyncs; 7227 // CODEGEN : file ../vk_helper.py line #1061 7228 ss[3] << "0x" << (void*)pStruct->pAcquireKeys; 7229 // CODEGEN : file ../vk_helper.py line #1061 7230 ss[4] << "0x" << (void*)pStruct->pAcquireTimeoutMilliseconds; 7231 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7232 ss[5] << pStruct->releaseCount; 7233 // CODEGEN : file ../vk_helper.py line #1061 7234 ss[6] << "0x" << (void*)pStruct->pReleaseSyncs; 7235 // CODEGEN : file ../vk_helper.py line #1061 7236 ss[7] << "0x" << (void*)pStruct->pReleaseKeys; 7237 // CODEGEN : file ../vk_helper.py line #1113 7238 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 7239 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 7240 final_str = final_str + prefix + "acquireCount = " + ss[1].str() + "\n"; 7241 final_str = final_str + prefix + "pAcquireSyncs = " + ss[2].str() + "\n"; 7242 final_str = final_str + prefix + "pAcquireKeys = " + ss[3].str() + "\n"; 7243 final_str = final_str + prefix + "pAcquireTimeoutMilliseconds = " + ss[4].str() + "\n"; 7244 final_str = final_str + prefix + "releaseCount = " + ss[5].str() + "\n"; 7245 final_str = final_str + prefix + "pReleaseSyncs = " + ss[6].str() + "\n"; 7246 final_str = final_str + prefix + "pReleaseKeys = " + ss[7].str() + "\n"; 7247 final_str = final_str + stp_strs[5] + stp_strs[4] + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 7248 return final_str; 7249 } 7250 #endif //VK_USE_PLATFORM_WIN32_KHR 7251 // CODEGEN : file ../vk_helper.py line #907 7252 #ifdef VK_USE_PLATFORM_WIN32_KHR 7253 std::string vk_print_vkwin32surfacecreateinfokhr(const VkWin32SurfaceCreateInfoKHR* pStruct, const std::string prefix) 7254 { 7255 // CODEGEN : file ../vk_helper.py line #913 7256 using namespace StreamControl; 7257 using namespace std; 7258 string final_str; 7259 string tmp_str; 7260 string extra_indent = " " + prefix; 7261 stringstream ss[4]; 7262 string stp_strs[1]; 7263 // CODEGEN : file ../vk_helper.py line #1012 7264 if (pStruct->pNext) { 7265 // CODEGEN : file ../vk_helper.py line #1016 7266 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 7267 ss[0] << "0x" << &pStruct->pNext; 7268 // CODEGEN : file ../vk_helper.py line #1028 7269 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 7270 ss[0].str(""); 7271 } 7272 else 7273 stp_strs[0] = ""; 7274 // CODEGEN : file ../vk_helper.py line #1070 7275 if (StreamControl::writeAddress) 7276 ss[0] << "0x" << pStruct->pNext; 7277 else 7278 ss[0].str("address"); 7279 // CODEGEN : file ../vk_helper.py line #1086 7280 ss[1] << "0x" << pStruct->flags; 7281 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7282 ss[2] << pStruct->hinstance; 7283 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7284 ss[3] << pStruct->hwnd; 7285 // CODEGEN : file ../vk_helper.py line #1113 7286 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 7287 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 7288 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 7289 final_str = final_str + prefix + "hinstance = " + ss[2].str() + "\n"; 7290 final_str = final_str + prefix + "hwnd = " + ss[3].str() + "\n"; 7291 final_str = final_str + stp_strs[0]; 7292 return final_str; 7293 } 7294 #endif //VK_USE_PLATFORM_WIN32_KHR 7295 // CODEGEN : file ../vk_helper.py line #907 7296 std::string vk_print_vkwritedescriptorset(const VkWriteDescriptorSet* pStruct, const std::string prefix) 7297 { 7298 // CODEGEN : file ../vk_helper.py line #913 7299 using namespace StreamControl; 7300 using namespace std; 7301 string final_str; 7302 string tmp_str; 7303 string extra_indent = " " + prefix; 7304 stringstream ss[8]; 7305 string stp_strs[4]; 7306 // CODEGEN : file ../vk_helper.py line #1012 7307 if (pStruct->pNext) { 7308 // CODEGEN : file ../vk_helper.py line #1016 7309 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 7310 ss[0] << "0x" << &pStruct->pNext; 7311 // CODEGEN : file ../vk_helper.py line #1028 7312 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 7313 ss[0].str(""); 7314 } 7315 else 7316 stp_strs[0] = ""; 7317 // CODEGEN : file ../vk_helper.py line #932 7318 // CODEGEN : file ../vk_helper.py line #934 7319 // CODEGEN : file ../vk_helper.py line #939 7320 stp_strs[1] = ""; 7321 stringstream index_ss; 7322 if ((pStruct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || 7323 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) || 7324 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || 7325 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)) { 7326 if (pStruct->pImageInfo) { 7327 for (uint32_t i = 0; i < pStruct->descriptorCount; i++) { 7328 index_ss.str(""); 7329 index_ss << i; 7330 // CODEGEN : file ../vk_helper.py line #980 7331 ss[1] << "0x" << &pStruct->pImageInfo[i]; 7332 tmp_str = vk_print_vkdescriptorimageinfo(&pStruct->pImageInfo[i], extra_indent); 7333 // CODEGEN : file ../vk_helper.py line #984 7334 stp_strs[1] += " " + prefix + "pImageInfo[" + index_ss.str() + "] (addr)\n" + tmp_str; 7335 // CODEGEN : file ../vk_helper.py line #1000 7336 ss[1].str(""); 7337 } 7338 } 7339 } 7340 // CODEGEN : file ../vk_helper.py line #932 7341 // CODEGEN : file ../vk_helper.py line #934 7342 // CODEGEN : file ../vk_helper.py line #939 7343 stp_strs[2] = ""; 7344 if ((pStruct->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || 7345 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || 7346 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || 7347 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { 7348 if (pStruct->pBufferInfo) { 7349 for (uint32_t i = 0; i < pStruct->descriptorCount; i++) { 7350 index_ss.str(""); 7351 index_ss << i; 7352 // CODEGEN : file ../vk_helper.py line #980 7353 ss[2] << "0x" << &pStruct->pBufferInfo[i]; 7354 tmp_str = vk_print_vkdescriptorbufferinfo(&pStruct->pBufferInfo[i], extra_indent); 7355 // CODEGEN : file ../vk_helper.py line #984 7356 stp_strs[2] += " " + prefix + "pBufferInfo[" + index_ss.str() + "] (addr)\n" + tmp_str; 7357 // CODEGEN : file ../vk_helper.py line #1000 7358 ss[2].str(""); 7359 } 7360 } 7361 } 7362 // CODEGEN : file ../vk_helper.py line #932 7363 // CODEGEN : file ../vk_helper.py line #934 7364 // CODEGEN : file ../vk_helper.py line #939 7365 stp_strs[3] = ""; 7366 if ((pStruct->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) || 7367 (pStruct->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) { 7368 if (pStruct->pTexelBufferView) { 7369 for (uint32_t i = 0; i < pStruct->descriptorCount; i++) { 7370 index_ss.str(""); 7371 index_ss << i; 7372 // CODEGEN : file ../vk_helper.py line #990 7373 ss[3] << "0x" << pStruct->pTexelBufferView[i]; 7374 stp_strs[3] += " " + prefix + "pTexelBufferView[" + index_ss.str() + "].handle = " + ss[3].str() + "\n"; 7375 // CODEGEN : file ../vk_helper.py line #1000 7376 ss[3].str(""); 7377 } 7378 } 7379 } 7380 // CODEGEN : file ../vk_helper.py line #1070 7381 if (StreamControl::writeAddress) 7382 ss[0] << "0x" << pStruct->pNext; 7383 else 7384 ss[0].str("address"); 7385 // CODEGEN : file ../vk_helper.py line #1086 7386 ss[1] << "0x" << pStruct->dstSet; 7387 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7388 ss[2] << pStruct->dstBinding; 7389 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7390 ss[3] << pStruct->dstArrayElement; 7391 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7392 ss[4] << pStruct->descriptorCount; 7393 // CODEGEN : file ../vk_helper.py line #1061 7394 ss[5] << "0x" << (void*)pStruct->pImageInfo; 7395 // CODEGEN : file ../vk_helper.py line #1061 7396 ss[6] << "0x" << (void*)pStruct->pBufferInfo; 7397 // CODEGEN : file ../vk_helper.py line #1061 7398 ss[7] << "0x" << (void*)pStruct->pTexelBufferView; 7399 // CODEGEN : file ../vk_helper.py line #1113 7400 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 7401 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 7402 final_str = final_str + prefix + "dstSet = " + ss[1].str() + "\n"; 7403 final_str = final_str + prefix + "dstBinding = " + ss[2].str() + "\n"; 7404 final_str = final_str + prefix + "dstArrayElement = " + ss[3].str() + "\n"; 7405 final_str = final_str + prefix + "descriptorCount = " + ss[4].str() + "\n"; 7406 final_str = final_str + prefix + "descriptorType = " + string_VkDescriptorType(pStruct->descriptorType) + "\n"; 7407 final_str = final_str + prefix + "pImageInfo = " + ss[5].str() + "\n"; 7408 final_str = final_str + prefix + "pBufferInfo = " + ss[6].str() + "\n"; 7409 final_str = final_str + prefix + "pTexelBufferView = " + ss[7].str() + "\n"; 7410 final_str = final_str + stp_strs[3] + stp_strs[2] + stp_strs[1] + stp_strs[0]; 7411 return final_str; 7412 } 7413 // CODEGEN : file ../vk_helper.py line #907 7414 #ifdef VK_USE_PLATFORM_XCB_KHR 7415 std::string vk_print_vkxcbsurfacecreateinfokhr(const VkXcbSurfaceCreateInfoKHR* pStruct, const std::string prefix) 7416 { 7417 // CODEGEN : file ../vk_helper.py line #913 7418 using namespace StreamControl; 7419 using namespace std; 7420 string final_str; 7421 string tmp_str; 7422 string extra_indent = " " + prefix; 7423 stringstream ss[4]; 7424 string stp_strs[1]; 7425 // CODEGEN : file ../vk_helper.py line #1012 7426 if (pStruct->pNext) { 7427 // CODEGEN : file ../vk_helper.py line #1016 7428 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 7429 ss[0] << "0x" << &pStruct->pNext; 7430 // CODEGEN : file ../vk_helper.py line #1028 7431 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 7432 ss[0].str(""); 7433 } 7434 else 7435 stp_strs[0] = ""; 7436 // CODEGEN : file ../vk_helper.py line #1070 7437 if (StreamControl::writeAddress) 7438 ss[0] << "0x" << pStruct->pNext; 7439 else 7440 ss[0].str("address"); 7441 // CODEGEN : file ../vk_helper.py line #1086 7442 ss[1] << "0x" << pStruct->flags; 7443 // CODEGEN : file ../vk_helper.py line #1086 7444 ss[2] << "0x" << pStruct->connection; 7445 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7446 ss[3] << pStruct->window; 7447 // CODEGEN : file ../vk_helper.py line #1113 7448 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 7449 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 7450 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 7451 final_str = final_str + prefix + "connection = " + ss[2].str() + "\n"; 7452 final_str = final_str + prefix + "window = " + ss[3].str() + "\n"; 7453 final_str = final_str + stp_strs[0]; 7454 return final_str; 7455 } 7456 #endif //VK_USE_PLATFORM_XCB_KHR 7457 // CODEGEN : file ../vk_helper.py line #907 7458 #ifdef VK_USE_PLATFORM_XLIB_KHR 7459 std::string vk_print_vkxlibsurfacecreateinfokhr(const VkXlibSurfaceCreateInfoKHR* pStruct, const std::string prefix) 7460 { 7461 // CODEGEN : file ../vk_helper.py line #913 7462 using namespace StreamControl; 7463 using namespace std; 7464 string final_str; 7465 string tmp_str; 7466 string extra_indent = " " + prefix; 7467 stringstream ss[4]; 7468 string stp_strs[1]; 7469 // CODEGEN : file ../vk_helper.py line #1012 7470 if (pStruct->pNext) { 7471 // CODEGEN : file ../vk_helper.py line #1016 7472 tmp_str = dynamic_display((void*)pStruct->pNext, prefix); 7473 ss[0] << "0x" << &pStruct->pNext; 7474 // CODEGEN : file ../vk_helper.py line #1028 7475 stp_strs[0] = " " + prefix + "pNext (addr)\n" + tmp_str; 7476 ss[0].str(""); 7477 } 7478 else 7479 stp_strs[0] = ""; 7480 // CODEGEN : file ../vk_helper.py line #1070 7481 if (StreamControl::writeAddress) 7482 ss[0] << "0x" << pStruct->pNext; 7483 else 7484 ss[0].str("address"); 7485 // CODEGEN : file ../vk_helper.py line #1086 7486 ss[1] << "0x" << pStruct->flags; 7487 // CODEGEN : file ../vk_helper.py line #1086 7488 ss[2] << "0x" << pStruct->dpy; 7489 // CODEGEN : file ../vk_helper.py line #1093: NB Edit this section to choose hex vs dec output by variable name 7490 ss[3] << pStruct->window; 7491 // CODEGEN : file ../vk_helper.py line #1113 7492 final_str = final_str + prefix + "sType = " + string_VkStructureType(pStruct->sType) + "\n"; 7493 final_str = final_str + prefix + "pNext = " + ss[0].str() + "\n"; 7494 final_str = final_str + prefix + "flags = " + ss[1].str() + "\n"; 7495 final_str = final_str + prefix + "dpy = " + ss[2].str() + "\n"; 7496 final_str = final_str + prefix + "window = " + ss[3].str() + "\n"; 7497 final_str = final_str + stp_strs[0]; 7498 return final_str; 7499 } 7500 #endif //VK_USE_PLATFORM_XLIB_KHR 7501 // CODEGEN : file ../vk_helper.py line #1122 7502 std::string string_convert_helper(const void* toString, const std::string prefix) 7503 { 7504 using namespace StreamControl; 7505 using namespace std; 7506 stringstream ss; 7507 ss << toString; 7508 string final_str = prefix + ss.str(); 7509 return final_str; 7510 } 7511 // CODEGEN : file ../vk_helper.py line #1131 7512 std::string string_convert_helper(const uint64_t toString, const std::string prefix) 7513 { 7514 using namespace StreamControl; 7515 using namespace std; 7516 stringstream ss; 7517 ss << toString; 7518 string final_str = prefix + ss.str(); 7519 return final_str; 7520 } 7521 // CODEGEN : file ../vk_helper.py line #1141 7522 std::string string_convert_helper(VkSurfaceFormatKHR toString, const std::string prefix) 7523 { 7524 using namespace std; 7525 string final_str = prefix + "format = " + string_VkFormat(toString.format) + "format = " + string_VkColorSpaceKHR(toString.colorSpace); 7526 return final_str; 7527 } 7528 // CODEGEN : file ../vk_helper.py line #1148 7529 std::string dynamic_display(const void* pStruct, const std::string prefix) 7530 { 7531 using namespace std; 7532 // Cast to APP_INFO ptr initially just to pull sType off struct 7533 if (pStruct == NULL) { 7534 7535 return string(); 7536 } 7537 7538 VkStructureType sType = ((VkApplicationInfo*)pStruct)->sType; 7539 string indent = " "; 7540 indent += prefix; 7541 switch (sType) 7542 { 7543 case VK_STRUCTURE_TYPE_APPLICATION_INFO: 7544 { 7545 return vk_print_vkapplicationinfo((VkApplicationInfo*)pStruct, indent); 7546 } 7547 break; 7548 case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: 7549 { 7550 return vk_print_vkbindsparseinfo((VkBindSparseInfo*)pStruct, indent); 7551 } 7552 break; 7553 case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: 7554 { 7555 return vk_print_vkbuffercreateinfo((VkBufferCreateInfo*)pStruct, indent); 7556 } 7557 break; 7558 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: 7559 { 7560 return vk_print_vkbuffermemorybarrier((VkBufferMemoryBarrier*)pStruct, indent); 7561 } 7562 break; 7563 case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: 7564 { 7565 return vk_print_vkbufferviewcreateinfo((VkBufferViewCreateInfo*)pStruct, indent); 7566 } 7567 break; 7568 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: 7569 { 7570 return vk_print_vkcommandbufferallocateinfo((VkCommandBufferAllocateInfo*)pStruct, indent); 7571 } 7572 break; 7573 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: 7574 { 7575 return vk_print_vkcommandbufferbegininfo((VkCommandBufferBeginInfo*)pStruct, indent); 7576 } 7577 break; 7578 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: 7579 { 7580 return vk_print_vkcommandbufferinheritanceinfo((VkCommandBufferInheritanceInfo*)pStruct, indent); 7581 } 7582 break; 7583 case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: 7584 { 7585 return vk_print_vkcommandpoolcreateinfo((VkCommandPoolCreateInfo*)pStruct, indent); 7586 } 7587 break; 7588 case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: 7589 { 7590 return vk_print_vkcomputepipelinecreateinfo((VkComputePipelineCreateInfo*)pStruct, indent); 7591 } 7592 break; 7593 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: 7594 { 7595 return vk_print_vkcopydescriptorset((VkCopyDescriptorSet*)pStruct, indent); 7596 } 7597 break; 7598 case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: 7599 { 7600 return vk_print_vkdescriptorpoolcreateinfo((VkDescriptorPoolCreateInfo*)pStruct, indent); 7601 } 7602 break; 7603 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: 7604 { 7605 return vk_print_vkdescriptorsetallocateinfo((VkDescriptorSetAllocateInfo*)pStruct, indent); 7606 } 7607 break; 7608 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: 7609 { 7610 return vk_print_vkdescriptorsetlayoutcreateinfo((VkDescriptorSetLayoutCreateInfo*)pStruct, indent); 7611 } 7612 break; 7613 case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: 7614 { 7615 return vk_print_vkdevicecreateinfo((VkDeviceCreateInfo*)pStruct, indent); 7616 } 7617 break; 7618 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: 7619 { 7620 return vk_print_vkdevicequeuecreateinfo((VkDeviceQueueCreateInfo*)pStruct, indent); 7621 } 7622 break; 7623 case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: 7624 { 7625 return vk_print_vkeventcreateinfo((VkEventCreateInfo*)pStruct, indent); 7626 } 7627 break; 7628 case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: 7629 { 7630 return vk_print_vkfencecreateinfo((VkFenceCreateInfo*)pStruct, indent); 7631 } 7632 break; 7633 case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: 7634 { 7635 return vk_print_vkframebuffercreateinfo((VkFramebufferCreateInfo*)pStruct, indent); 7636 } 7637 break; 7638 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: 7639 { 7640 return vk_print_vkgraphicspipelinecreateinfo((VkGraphicsPipelineCreateInfo*)pStruct, indent); 7641 } 7642 break; 7643 case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: 7644 { 7645 return vk_print_vkimagecreateinfo((VkImageCreateInfo*)pStruct, indent); 7646 } 7647 break; 7648 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: 7649 { 7650 return vk_print_vkimagememorybarrier((VkImageMemoryBarrier*)pStruct, indent); 7651 } 7652 break; 7653 case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: 7654 { 7655 return vk_print_vkimageviewcreateinfo((VkImageViewCreateInfo*)pStruct, indent); 7656 } 7657 break; 7658 case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: 7659 { 7660 return vk_print_vkinstancecreateinfo((VkInstanceCreateInfo*)pStruct, indent); 7661 } 7662 break; 7663 case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: 7664 { 7665 return vk_print_vkmappedmemoryrange((VkMappedMemoryRange*)pStruct, indent); 7666 } 7667 break; 7668 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: 7669 { 7670 return vk_print_vkmemoryallocateinfo((VkMemoryAllocateInfo*)pStruct, indent); 7671 } 7672 break; 7673 case VK_STRUCTURE_TYPE_MEMORY_BARRIER: 7674 { 7675 return vk_print_vkmemorybarrier((VkMemoryBarrier*)pStruct, indent); 7676 } 7677 break; 7678 case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: 7679 { 7680 return vk_print_vkpipelinecachecreateinfo((VkPipelineCacheCreateInfo*)pStruct, indent); 7681 } 7682 break; 7683 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: 7684 { 7685 return vk_print_vkpipelinecolorblendstatecreateinfo((VkPipelineColorBlendStateCreateInfo*)pStruct, indent); 7686 } 7687 break; 7688 case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: 7689 { 7690 return vk_print_vkpipelinedepthstencilstatecreateinfo((VkPipelineDepthStencilStateCreateInfo*)pStruct, indent); 7691 } 7692 break; 7693 case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: 7694 { 7695 return vk_print_vkpipelinedynamicstatecreateinfo((VkPipelineDynamicStateCreateInfo*)pStruct, indent); 7696 } 7697 break; 7698 case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: 7699 { 7700 return vk_print_vkpipelineinputassemblystatecreateinfo((VkPipelineInputAssemblyStateCreateInfo*)pStruct, indent); 7701 } 7702 break; 7703 case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: 7704 { 7705 return vk_print_vkpipelinelayoutcreateinfo((VkPipelineLayoutCreateInfo*)pStruct, indent); 7706 } 7707 break; 7708 case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: 7709 { 7710 return vk_print_vkpipelinemultisamplestatecreateinfo((VkPipelineMultisampleStateCreateInfo*)pStruct, indent); 7711 } 7712 break; 7713 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: 7714 { 7715 return vk_print_vkpipelinerasterizationstatecreateinfo((VkPipelineRasterizationStateCreateInfo*)pStruct, indent); 7716 } 7717 break; 7718 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: 7719 { 7720 return vk_print_vkpipelineshaderstagecreateinfo((VkPipelineShaderStageCreateInfo*)pStruct, indent); 7721 } 7722 break; 7723 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: 7724 { 7725 return vk_print_vkpipelinetessellationstatecreateinfo((VkPipelineTessellationStateCreateInfo*)pStruct, indent); 7726 } 7727 break; 7728 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: 7729 { 7730 return vk_print_vkpipelinevertexinputstatecreateinfo((VkPipelineVertexInputStateCreateInfo*)pStruct, indent); 7731 } 7732 break; 7733 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: 7734 { 7735 return vk_print_vkpipelineviewportstatecreateinfo((VkPipelineViewportStateCreateInfo*)pStruct, indent); 7736 } 7737 break; 7738 case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: 7739 { 7740 return vk_print_vkquerypoolcreateinfo((VkQueryPoolCreateInfo*)pStruct, indent); 7741 } 7742 break; 7743 case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: 7744 { 7745 return vk_print_vkrenderpassbegininfo((VkRenderPassBeginInfo*)pStruct, indent); 7746 } 7747 break; 7748 case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: 7749 { 7750 return vk_print_vkrenderpasscreateinfo((VkRenderPassCreateInfo*)pStruct, indent); 7751 } 7752 break; 7753 case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: 7754 { 7755 return vk_print_vksamplercreateinfo((VkSamplerCreateInfo*)pStruct, indent); 7756 } 7757 break; 7758 case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: 7759 { 7760 return vk_print_vksemaphorecreateinfo((VkSemaphoreCreateInfo*)pStruct, indent); 7761 } 7762 break; 7763 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: 7764 { 7765 return vk_print_vkshadermodulecreateinfo((VkShaderModuleCreateInfo*)pStruct, indent); 7766 } 7767 break; 7768 case VK_STRUCTURE_TYPE_SUBMIT_INFO: 7769 { 7770 return vk_print_vksubmitinfo((VkSubmitInfo*)pStruct, indent); 7771 } 7772 break; 7773 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: 7774 { 7775 return vk_print_vkwritedescriptorset((VkWriteDescriptorSet*)pStruct, indent); 7776 } 7777 break; 7778 default: 7779 return string(); 7780 // CODEGEN : file ../vk_helper.py line #1174 7781 } 7782 }
