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