1 /* THIS FILE IS GENERATED. DO NOT EDIT. */ 2 3 /* 4 * Vulkan 5 * 6 * Copyright (c) 2015-2016 The Khronos Group Inc. 7 * Copyright (c) 2015-2016 Valve Corporation. 8 * Copyright (c) 2015-2016 LunarG, Inc. 9 * Copyright (c) 2015-2016 Google Inc. 10 * 11 * Licensed under the Apache License, Version 2.0 (the "License"); 12 * you may not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, 19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 * 23 * Author: Courtney Goeltzenleuchter <courtney (at) LunarG.com> 24 * Author: Tobin Ehlis <tobin (at) lunarg.com> 25 */ 26 //#includes, #defines, globals and such... 27 #include <vulkan/vulkan.h> 28 #include <vk_enum_string_helper.h> 29 #include <stdint.h> 30 #include <cinttypes> 31 #include <stdio.h> 32 #include <stdlib.h> 33 34 //class declaration 35 class vkallocationcallbacks_struct_wrapper 36 { 37 public: 38 vkallocationcallbacks_struct_wrapper(); 39 vkallocationcallbacks_struct_wrapper(VkAllocationCallbacks* pInStruct); 40 vkallocationcallbacks_struct_wrapper(const VkAllocationCallbacks* pInStruct); 41 42 virtual ~vkallocationcallbacks_struct_wrapper(); 43 44 void display_txt(); 45 void display_single_txt(); 46 void display_full_txt(); 47 48 void set_indent(uint32_t indent) { m_indent = indent; } 49 void* get_pUserData() { return m_struct.pUserData; } 50 void set_pUserData(void* inValue) { m_struct.pUserData = inValue; } 51 PFN_vkAllocationFunction get_pfnAllocation() { return m_struct.pfnAllocation; } 52 void set_pfnAllocation(PFN_vkAllocationFunction inValue) { m_struct.pfnAllocation = inValue; } 53 PFN_vkReallocationFunction get_pfnReallocation() { return m_struct.pfnReallocation; } 54 void set_pfnReallocation(PFN_vkReallocationFunction inValue) { m_struct.pfnReallocation = inValue; } 55 PFN_vkFreeFunction get_pfnFree() { return m_struct.pfnFree; } 56 void set_pfnFree(PFN_vkFreeFunction inValue) { m_struct.pfnFree = inValue; } 57 PFN_vkInternalAllocationNotification get_pfnInternalAllocation() { return m_struct.pfnInternalAllocation; } 58 void set_pfnInternalAllocation(PFN_vkInternalAllocationNotification inValue) { m_struct.pfnInternalAllocation = inValue; } 59 PFN_vkInternalFreeNotification get_pfnInternalFree() { return m_struct.pfnInternalFree; } 60 void set_pfnInternalFree(PFN_vkInternalFreeNotification inValue) { m_struct.pfnInternalFree = inValue; } 61 62 63 private: 64 VkAllocationCallbacks m_struct; 65 const VkAllocationCallbacks* m_origStructAddr; 66 uint32_t m_indent; 67 const char m_dummy_prefix; 68 void display_struct_members(); 69 70 }; 71 72 73 //class declaration 74 class vkandroidsurfacecreateinfokhr_struct_wrapper 75 { 76 public: 77 vkandroidsurfacecreateinfokhr_struct_wrapper(); 78 vkandroidsurfacecreateinfokhr_struct_wrapper(VkAndroidSurfaceCreateInfoKHR* pInStruct); 79 vkandroidsurfacecreateinfokhr_struct_wrapper(const VkAndroidSurfaceCreateInfoKHR* pInStruct); 80 81 virtual ~vkandroidsurfacecreateinfokhr_struct_wrapper(); 82 83 void display_txt(); 84 void display_single_txt(); 85 void display_full_txt(); 86 87 void set_indent(uint32_t indent) { m_indent = indent; } 88 VkStructureType get_sType() { return m_struct.sType; } 89 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 90 const void* get_pNext() { return m_struct.pNext; } 91 VkAndroidSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 92 void set_flags(VkAndroidSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 93 ANativeWindow* get_window() { return m_struct.window; } 94 void set_window(ANativeWindow* inValue) { m_struct.window = inValue; } 95 96 97 private: 98 VkAndroidSurfaceCreateInfoKHR m_struct; 99 const VkAndroidSurfaceCreateInfoKHR* m_origStructAddr; 100 uint32_t m_indent; 101 const char m_dummy_prefix; 102 void display_struct_members(); 103 104 }; 105 106 107 //class declaration 108 class vkapplicationinfo_struct_wrapper 109 { 110 public: 111 vkapplicationinfo_struct_wrapper(); 112 vkapplicationinfo_struct_wrapper(VkApplicationInfo* pInStruct); 113 vkapplicationinfo_struct_wrapper(const VkApplicationInfo* pInStruct); 114 115 virtual ~vkapplicationinfo_struct_wrapper(); 116 117 void display_txt(); 118 void display_single_txt(); 119 void display_full_txt(); 120 121 void set_indent(uint32_t indent) { m_indent = indent; } 122 VkStructureType get_sType() { return m_struct.sType; } 123 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 124 const void* get_pNext() { return m_struct.pNext; } 125 const char* get_pApplicationName() { return m_struct.pApplicationName; } 126 uint32_t get_applicationVersion() { return m_struct.applicationVersion; } 127 void set_applicationVersion(uint32_t inValue) { m_struct.applicationVersion = inValue; } 128 const char* get_pEngineName() { return m_struct.pEngineName; } 129 uint32_t get_engineVersion() { return m_struct.engineVersion; } 130 void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; } 131 uint32_t get_apiVersion() { return m_struct.apiVersion; } 132 void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; } 133 134 135 private: 136 VkApplicationInfo m_struct; 137 const VkApplicationInfo* m_origStructAddr; 138 uint32_t m_indent; 139 const char m_dummy_prefix; 140 void display_struct_members(); 141 142 }; 143 144 145 //class declaration 146 class vkattachmentdescription_struct_wrapper 147 { 148 public: 149 vkattachmentdescription_struct_wrapper(); 150 vkattachmentdescription_struct_wrapper(VkAttachmentDescription* pInStruct); 151 vkattachmentdescription_struct_wrapper(const VkAttachmentDescription* pInStruct); 152 153 virtual ~vkattachmentdescription_struct_wrapper(); 154 155 void display_txt(); 156 void display_single_txt(); 157 void display_full_txt(); 158 159 void set_indent(uint32_t indent) { m_indent = indent; } 160 VkAttachmentDescriptionFlags get_flags() { return m_struct.flags; } 161 void set_flags(VkAttachmentDescriptionFlags inValue) { m_struct.flags = inValue; } 162 VkFormat get_format() { return m_struct.format; } 163 void set_format(VkFormat inValue) { m_struct.format = inValue; } 164 VkSampleCountFlagBits get_samples() { return m_struct.samples; } 165 void set_samples(VkSampleCountFlagBits inValue) { m_struct.samples = inValue; } 166 VkAttachmentLoadOp get_loadOp() { return m_struct.loadOp; } 167 void set_loadOp(VkAttachmentLoadOp inValue) { m_struct.loadOp = inValue; } 168 VkAttachmentStoreOp get_storeOp() { return m_struct.storeOp; } 169 void set_storeOp(VkAttachmentStoreOp inValue) { m_struct.storeOp = inValue; } 170 VkAttachmentLoadOp get_stencilLoadOp() { return m_struct.stencilLoadOp; } 171 void set_stencilLoadOp(VkAttachmentLoadOp inValue) { m_struct.stencilLoadOp = inValue; } 172 VkAttachmentStoreOp get_stencilStoreOp() { return m_struct.stencilStoreOp; } 173 void set_stencilStoreOp(VkAttachmentStoreOp inValue) { m_struct.stencilStoreOp = inValue; } 174 VkImageLayout get_initialLayout() { return m_struct.initialLayout; } 175 void set_initialLayout(VkImageLayout inValue) { m_struct.initialLayout = inValue; } 176 VkImageLayout get_finalLayout() { return m_struct.finalLayout; } 177 void set_finalLayout(VkImageLayout inValue) { m_struct.finalLayout = inValue; } 178 179 180 private: 181 VkAttachmentDescription m_struct; 182 const VkAttachmentDescription* m_origStructAddr; 183 uint32_t m_indent; 184 const char m_dummy_prefix; 185 void display_struct_members(); 186 187 }; 188 189 190 //class declaration 191 class vkattachmentreference_struct_wrapper 192 { 193 public: 194 vkattachmentreference_struct_wrapper(); 195 vkattachmentreference_struct_wrapper(VkAttachmentReference* pInStruct); 196 vkattachmentreference_struct_wrapper(const VkAttachmentReference* pInStruct); 197 198 virtual ~vkattachmentreference_struct_wrapper(); 199 200 void display_txt(); 201 void display_single_txt(); 202 void display_full_txt(); 203 204 void set_indent(uint32_t indent) { m_indent = indent; } 205 uint32_t get_attachment() { return m_struct.attachment; } 206 void set_attachment(uint32_t inValue) { m_struct.attachment = inValue; } 207 VkImageLayout get_layout() { return m_struct.layout; } 208 void set_layout(VkImageLayout inValue) { m_struct.layout = inValue; } 209 210 211 private: 212 VkAttachmentReference m_struct; 213 const VkAttachmentReference* m_origStructAddr; 214 uint32_t m_indent; 215 const char m_dummy_prefix; 216 void display_struct_members(); 217 218 }; 219 220 221 //class declaration 222 class vkbindsparseinfo_struct_wrapper 223 { 224 public: 225 vkbindsparseinfo_struct_wrapper(); 226 vkbindsparseinfo_struct_wrapper(VkBindSparseInfo* pInStruct); 227 vkbindsparseinfo_struct_wrapper(const VkBindSparseInfo* pInStruct); 228 229 virtual ~vkbindsparseinfo_struct_wrapper(); 230 231 void display_txt(); 232 void display_single_txt(); 233 void display_full_txt(); 234 235 void set_indent(uint32_t indent) { m_indent = indent; } 236 VkStructureType get_sType() { return m_struct.sType; } 237 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 238 const void* get_pNext() { return m_struct.pNext; } 239 uint32_t get_waitSemaphoreCount() { return m_struct.waitSemaphoreCount; } 240 void set_waitSemaphoreCount(uint32_t inValue) { m_struct.waitSemaphoreCount = inValue; } 241 uint32_t get_bufferBindCount() { return m_struct.bufferBindCount; } 242 void set_bufferBindCount(uint32_t inValue) { m_struct.bufferBindCount = inValue; } 243 uint32_t get_imageOpaqueBindCount() { return m_struct.imageOpaqueBindCount; } 244 void set_imageOpaqueBindCount(uint32_t inValue) { m_struct.imageOpaqueBindCount = inValue; } 245 uint32_t get_imageBindCount() { return m_struct.imageBindCount; } 246 void set_imageBindCount(uint32_t inValue) { m_struct.imageBindCount = inValue; } 247 uint32_t get_signalSemaphoreCount() { return m_struct.signalSemaphoreCount; } 248 void set_signalSemaphoreCount(uint32_t inValue) { m_struct.signalSemaphoreCount = inValue; } 249 250 251 private: 252 VkBindSparseInfo m_struct; 253 const VkBindSparseInfo* m_origStructAddr; 254 uint32_t m_indent; 255 const char m_dummy_prefix; 256 void display_struct_members(); 257 258 }; 259 260 261 //class declaration 262 class vkbuffercopy_struct_wrapper 263 { 264 public: 265 vkbuffercopy_struct_wrapper(); 266 vkbuffercopy_struct_wrapper(VkBufferCopy* pInStruct); 267 vkbuffercopy_struct_wrapper(const VkBufferCopy* pInStruct); 268 269 virtual ~vkbuffercopy_struct_wrapper(); 270 271 void display_txt(); 272 void display_single_txt(); 273 void display_full_txt(); 274 275 void set_indent(uint32_t indent) { m_indent = indent; } 276 VkDeviceSize get_srcOffset() { return m_struct.srcOffset; } 277 void set_srcOffset(VkDeviceSize inValue) { m_struct.srcOffset = inValue; } 278 VkDeviceSize get_dstOffset() { return m_struct.dstOffset; } 279 void set_dstOffset(VkDeviceSize inValue) { m_struct.dstOffset = inValue; } 280 VkDeviceSize get_size() { return m_struct.size; } 281 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 282 283 284 private: 285 VkBufferCopy m_struct; 286 const VkBufferCopy* m_origStructAddr; 287 uint32_t m_indent; 288 const char m_dummy_prefix; 289 void display_struct_members(); 290 291 }; 292 293 294 //class declaration 295 class vkbuffercreateinfo_struct_wrapper 296 { 297 public: 298 vkbuffercreateinfo_struct_wrapper(); 299 vkbuffercreateinfo_struct_wrapper(VkBufferCreateInfo* pInStruct); 300 vkbuffercreateinfo_struct_wrapper(const VkBufferCreateInfo* pInStruct); 301 302 virtual ~vkbuffercreateinfo_struct_wrapper(); 303 304 void display_txt(); 305 void display_single_txt(); 306 void display_full_txt(); 307 308 void set_indent(uint32_t indent) { m_indent = indent; } 309 VkStructureType get_sType() { return m_struct.sType; } 310 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 311 const void* get_pNext() { return m_struct.pNext; } 312 VkBufferCreateFlags get_flags() { return m_struct.flags; } 313 void set_flags(VkBufferCreateFlags inValue) { m_struct.flags = inValue; } 314 VkDeviceSize get_size() { return m_struct.size; } 315 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 316 VkBufferUsageFlags get_usage() { return m_struct.usage; } 317 void set_usage(VkBufferUsageFlags inValue) { m_struct.usage = inValue; } 318 VkSharingMode get_sharingMode() { return m_struct.sharingMode; } 319 void set_sharingMode(VkSharingMode inValue) { m_struct.sharingMode = inValue; } 320 uint32_t get_queueFamilyIndexCount() { return m_struct.queueFamilyIndexCount; } 321 void set_queueFamilyIndexCount(uint32_t inValue) { m_struct.queueFamilyIndexCount = inValue; } 322 323 324 private: 325 VkBufferCreateInfo m_struct; 326 const VkBufferCreateInfo* m_origStructAddr; 327 uint32_t m_indent; 328 const char m_dummy_prefix; 329 void display_struct_members(); 330 331 }; 332 333 334 //class declaration 335 class vkbufferimagecopy_struct_wrapper 336 { 337 public: 338 vkbufferimagecopy_struct_wrapper(); 339 vkbufferimagecopy_struct_wrapper(VkBufferImageCopy* pInStruct); 340 vkbufferimagecopy_struct_wrapper(const VkBufferImageCopy* pInStruct); 341 342 virtual ~vkbufferimagecopy_struct_wrapper(); 343 344 void display_txt(); 345 void display_single_txt(); 346 void display_full_txt(); 347 348 void set_indent(uint32_t indent) { m_indent = indent; } 349 VkDeviceSize get_bufferOffset() { return m_struct.bufferOffset; } 350 void set_bufferOffset(VkDeviceSize inValue) { m_struct.bufferOffset = inValue; } 351 uint32_t get_bufferRowLength() { return m_struct.bufferRowLength; } 352 void set_bufferRowLength(uint32_t inValue) { m_struct.bufferRowLength = inValue; } 353 uint32_t get_bufferImageHeight() { return m_struct.bufferImageHeight; } 354 void set_bufferImageHeight(uint32_t inValue) { m_struct.bufferImageHeight = inValue; } 355 VkImageSubresourceLayers get_imageSubresource() { return m_struct.imageSubresource; } 356 void set_imageSubresource(VkImageSubresourceLayers inValue) { m_struct.imageSubresource = inValue; } 357 VkOffset3D get_imageOffset() { return m_struct.imageOffset; } 358 void set_imageOffset(VkOffset3D inValue) { m_struct.imageOffset = inValue; } 359 VkExtent3D get_imageExtent() { return m_struct.imageExtent; } 360 void set_imageExtent(VkExtent3D inValue) { m_struct.imageExtent = inValue; } 361 362 363 private: 364 VkBufferImageCopy m_struct; 365 const VkBufferImageCopy* m_origStructAddr; 366 uint32_t m_indent; 367 const char m_dummy_prefix; 368 void display_struct_members(); 369 370 }; 371 372 373 //class declaration 374 class vkbuffermemorybarrier_struct_wrapper 375 { 376 public: 377 vkbuffermemorybarrier_struct_wrapper(); 378 vkbuffermemorybarrier_struct_wrapper(VkBufferMemoryBarrier* pInStruct); 379 vkbuffermemorybarrier_struct_wrapper(const VkBufferMemoryBarrier* pInStruct); 380 381 virtual ~vkbuffermemorybarrier_struct_wrapper(); 382 383 void display_txt(); 384 void display_single_txt(); 385 void display_full_txt(); 386 387 void set_indent(uint32_t indent) { m_indent = indent; } 388 VkStructureType get_sType() { return m_struct.sType; } 389 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 390 const void* get_pNext() { return m_struct.pNext; } 391 VkAccessFlags get_srcAccessMask() { return m_struct.srcAccessMask; } 392 void set_srcAccessMask(VkAccessFlags inValue) { m_struct.srcAccessMask = inValue; } 393 VkAccessFlags get_dstAccessMask() { return m_struct.dstAccessMask; } 394 void set_dstAccessMask(VkAccessFlags inValue) { m_struct.dstAccessMask = inValue; } 395 uint32_t get_srcQueueFamilyIndex() { return m_struct.srcQueueFamilyIndex; } 396 void set_srcQueueFamilyIndex(uint32_t inValue) { m_struct.srcQueueFamilyIndex = inValue; } 397 uint32_t get_dstQueueFamilyIndex() { return m_struct.dstQueueFamilyIndex; } 398 void set_dstQueueFamilyIndex(uint32_t inValue) { m_struct.dstQueueFamilyIndex = inValue; } 399 VkBuffer get_buffer() { return m_struct.buffer; } 400 void set_buffer(VkBuffer inValue) { m_struct.buffer = inValue; } 401 VkDeviceSize get_offset() { return m_struct.offset; } 402 void set_offset(VkDeviceSize inValue) { m_struct.offset = inValue; } 403 VkDeviceSize get_size() { return m_struct.size; } 404 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 405 406 407 private: 408 VkBufferMemoryBarrier m_struct; 409 const VkBufferMemoryBarrier* m_origStructAddr; 410 uint32_t m_indent; 411 const char m_dummy_prefix; 412 void display_struct_members(); 413 414 }; 415 416 417 //class declaration 418 class vkbufferviewcreateinfo_struct_wrapper 419 { 420 public: 421 vkbufferviewcreateinfo_struct_wrapper(); 422 vkbufferviewcreateinfo_struct_wrapper(VkBufferViewCreateInfo* pInStruct); 423 vkbufferviewcreateinfo_struct_wrapper(const VkBufferViewCreateInfo* pInStruct); 424 425 virtual ~vkbufferviewcreateinfo_struct_wrapper(); 426 427 void display_txt(); 428 void display_single_txt(); 429 void display_full_txt(); 430 431 void set_indent(uint32_t indent) { m_indent = indent; } 432 VkStructureType get_sType() { return m_struct.sType; } 433 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 434 const void* get_pNext() { return m_struct.pNext; } 435 VkBufferViewCreateFlags get_flags() { return m_struct.flags; } 436 void set_flags(VkBufferViewCreateFlags inValue) { m_struct.flags = inValue; } 437 VkBuffer get_buffer() { return m_struct.buffer; } 438 void set_buffer(VkBuffer inValue) { m_struct.buffer = inValue; } 439 VkFormat get_format() { return m_struct.format; } 440 void set_format(VkFormat inValue) { m_struct.format = inValue; } 441 VkDeviceSize get_offset() { return m_struct.offset; } 442 void set_offset(VkDeviceSize inValue) { m_struct.offset = inValue; } 443 VkDeviceSize get_range() { return m_struct.range; } 444 void set_range(VkDeviceSize inValue) { m_struct.range = inValue; } 445 446 447 private: 448 VkBufferViewCreateInfo m_struct; 449 const VkBufferViewCreateInfo* m_origStructAddr; 450 uint32_t m_indent; 451 const char m_dummy_prefix; 452 void display_struct_members(); 453 454 }; 455 456 457 //class declaration 458 class vkclearattachment_struct_wrapper 459 { 460 public: 461 vkclearattachment_struct_wrapper(); 462 vkclearattachment_struct_wrapper(VkClearAttachment* pInStruct); 463 vkclearattachment_struct_wrapper(const VkClearAttachment* pInStruct); 464 465 virtual ~vkclearattachment_struct_wrapper(); 466 467 void display_txt(); 468 void display_single_txt(); 469 void display_full_txt(); 470 471 void set_indent(uint32_t indent) { m_indent = indent; } 472 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 473 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 474 uint32_t get_colorAttachment() { return m_struct.colorAttachment; } 475 void set_colorAttachment(uint32_t inValue) { m_struct.colorAttachment = inValue; } 476 VkClearValue get_clearValue() { return m_struct.clearValue; } 477 void set_clearValue(VkClearValue inValue) { m_struct.clearValue = inValue; } 478 479 480 private: 481 VkClearAttachment m_struct; 482 const VkClearAttachment* m_origStructAddr; 483 uint32_t m_indent; 484 const char m_dummy_prefix; 485 void display_struct_members(); 486 487 }; 488 489 490 //class declaration 491 class vkclearcolorvalue_struct_wrapper 492 { 493 public: 494 vkclearcolorvalue_struct_wrapper(); 495 vkclearcolorvalue_struct_wrapper(VkClearColorValue* pInStruct); 496 vkclearcolorvalue_struct_wrapper(const VkClearColorValue* pInStruct); 497 498 virtual ~vkclearcolorvalue_struct_wrapper(); 499 500 void display_txt(); 501 void display_single_txt(); 502 void display_full_txt(); 503 504 void set_indent(uint32_t indent) { m_indent = indent; } 505 506 507 private: 508 VkClearColorValue m_struct; 509 const VkClearColorValue* m_origStructAddr; 510 uint32_t m_indent; 511 const char m_dummy_prefix; 512 void display_struct_members(); 513 514 }; 515 516 517 //class declaration 518 class vkcleardepthstencilvalue_struct_wrapper 519 { 520 public: 521 vkcleardepthstencilvalue_struct_wrapper(); 522 vkcleardepthstencilvalue_struct_wrapper(VkClearDepthStencilValue* pInStruct); 523 vkcleardepthstencilvalue_struct_wrapper(const VkClearDepthStencilValue* pInStruct); 524 525 virtual ~vkcleardepthstencilvalue_struct_wrapper(); 526 527 void display_txt(); 528 void display_single_txt(); 529 void display_full_txt(); 530 531 void set_indent(uint32_t indent) { m_indent = indent; } 532 float get_depth() { return m_struct.depth; } 533 void set_depth(float inValue) { m_struct.depth = inValue; } 534 uint32_t get_stencil() { return m_struct.stencil; } 535 void set_stencil(uint32_t inValue) { m_struct.stencil = inValue; } 536 537 538 private: 539 VkClearDepthStencilValue m_struct; 540 const VkClearDepthStencilValue* m_origStructAddr; 541 uint32_t m_indent; 542 const char m_dummy_prefix; 543 void display_struct_members(); 544 545 }; 546 547 548 //class declaration 549 class vkclearrect_struct_wrapper 550 { 551 public: 552 vkclearrect_struct_wrapper(); 553 vkclearrect_struct_wrapper(VkClearRect* pInStruct); 554 vkclearrect_struct_wrapper(const VkClearRect* pInStruct); 555 556 virtual ~vkclearrect_struct_wrapper(); 557 558 void display_txt(); 559 void display_single_txt(); 560 void display_full_txt(); 561 562 void set_indent(uint32_t indent) { m_indent = indent; } 563 VkRect2D get_rect() { return m_struct.rect; } 564 void set_rect(VkRect2D inValue) { m_struct.rect = inValue; } 565 uint32_t get_baseArrayLayer() { return m_struct.baseArrayLayer; } 566 void set_baseArrayLayer(uint32_t inValue) { m_struct.baseArrayLayer = inValue; } 567 uint32_t get_layerCount() { return m_struct.layerCount; } 568 void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; } 569 570 571 private: 572 VkClearRect m_struct; 573 const VkClearRect* m_origStructAddr; 574 uint32_t m_indent; 575 const char m_dummy_prefix; 576 void display_struct_members(); 577 578 }; 579 580 581 //class declaration 582 class vkclearvalue_struct_wrapper 583 { 584 public: 585 vkclearvalue_struct_wrapper(); 586 vkclearvalue_struct_wrapper(VkClearValue* pInStruct); 587 vkclearvalue_struct_wrapper(const VkClearValue* pInStruct); 588 589 virtual ~vkclearvalue_struct_wrapper(); 590 591 void display_txt(); 592 void display_single_txt(); 593 void display_full_txt(); 594 595 void set_indent(uint32_t indent) { m_indent = indent; } 596 VkClearColorValue get_color() { return m_struct.color; } 597 void set_color(VkClearColorValue inValue) { m_struct.color = inValue; } 598 VkClearDepthStencilValue get_depthStencil() { return m_struct.depthStencil; } 599 void set_depthStencil(VkClearDepthStencilValue inValue) { m_struct.depthStencil = inValue; } 600 601 602 private: 603 VkClearValue m_struct; 604 const VkClearValue* m_origStructAddr; 605 uint32_t m_indent; 606 const char m_dummy_prefix; 607 void display_struct_members(); 608 609 }; 610 611 612 //class declaration 613 class vkcommandbufferallocateinfo_struct_wrapper 614 { 615 public: 616 vkcommandbufferallocateinfo_struct_wrapper(); 617 vkcommandbufferallocateinfo_struct_wrapper(VkCommandBufferAllocateInfo* pInStruct); 618 vkcommandbufferallocateinfo_struct_wrapper(const VkCommandBufferAllocateInfo* pInStruct); 619 620 virtual ~vkcommandbufferallocateinfo_struct_wrapper(); 621 622 void display_txt(); 623 void display_single_txt(); 624 void display_full_txt(); 625 626 void set_indent(uint32_t indent) { m_indent = indent; } 627 VkStructureType get_sType() { return m_struct.sType; } 628 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 629 const void* get_pNext() { return m_struct.pNext; } 630 VkCommandPool get_commandPool() { return m_struct.commandPool; } 631 void set_commandPool(VkCommandPool inValue) { m_struct.commandPool = inValue; } 632 VkCommandBufferLevel get_level() { return m_struct.level; } 633 void set_level(VkCommandBufferLevel inValue) { m_struct.level = inValue; } 634 uint32_t get_commandBufferCount() { return m_struct.commandBufferCount; } 635 void set_commandBufferCount(uint32_t inValue) { m_struct.commandBufferCount = inValue; } 636 637 638 private: 639 VkCommandBufferAllocateInfo m_struct; 640 const VkCommandBufferAllocateInfo* m_origStructAddr; 641 uint32_t m_indent; 642 const char m_dummy_prefix; 643 void display_struct_members(); 644 645 }; 646 647 648 //class declaration 649 class vkcommandbufferbegininfo_struct_wrapper 650 { 651 public: 652 vkcommandbufferbegininfo_struct_wrapper(); 653 vkcommandbufferbegininfo_struct_wrapper(VkCommandBufferBeginInfo* pInStruct); 654 vkcommandbufferbegininfo_struct_wrapper(const VkCommandBufferBeginInfo* pInStruct); 655 656 virtual ~vkcommandbufferbegininfo_struct_wrapper(); 657 658 void display_txt(); 659 void display_single_txt(); 660 void display_full_txt(); 661 662 void set_indent(uint32_t indent) { m_indent = indent; } 663 VkStructureType get_sType() { return m_struct.sType; } 664 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 665 const void* get_pNext() { return m_struct.pNext; } 666 VkCommandBufferUsageFlags get_flags() { return m_struct.flags; } 667 void set_flags(VkCommandBufferUsageFlags inValue) { m_struct.flags = inValue; } 668 const VkCommandBufferInheritanceInfo* get_pInheritanceInfo() { return m_struct.pInheritanceInfo; } 669 670 671 private: 672 VkCommandBufferBeginInfo m_struct; 673 const VkCommandBufferBeginInfo* m_origStructAddr; 674 uint32_t m_indent; 675 const char m_dummy_prefix; 676 void display_struct_members(); 677 678 }; 679 680 681 //class declaration 682 class vkcommandbufferinheritanceinfo_struct_wrapper 683 { 684 public: 685 vkcommandbufferinheritanceinfo_struct_wrapper(); 686 vkcommandbufferinheritanceinfo_struct_wrapper(VkCommandBufferInheritanceInfo* pInStruct); 687 vkcommandbufferinheritanceinfo_struct_wrapper(const VkCommandBufferInheritanceInfo* pInStruct); 688 689 virtual ~vkcommandbufferinheritanceinfo_struct_wrapper(); 690 691 void display_txt(); 692 void display_single_txt(); 693 void display_full_txt(); 694 695 void set_indent(uint32_t indent) { m_indent = indent; } 696 VkStructureType get_sType() { return m_struct.sType; } 697 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 698 const void* get_pNext() { return m_struct.pNext; } 699 VkRenderPass get_renderPass() { return m_struct.renderPass; } 700 void set_renderPass(VkRenderPass inValue) { m_struct.renderPass = inValue; } 701 uint32_t get_subpass() { return m_struct.subpass; } 702 void set_subpass(uint32_t inValue) { m_struct.subpass = inValue; } 703 VkFramebuffer get_framebuffer() { return m_struct.framebuffer; } 704 void set_framebuffer(VkFramebuffer inValue) { m_struct.framebuffer = inValue; } 705 VkBool32 get_occlusionQueryEnable() { return m_struct.occlusionQueryEnable; } 706 void set_occlusionQueryEnable(VkBool32 inValue) { m_struct.occlusionQueryEnable = inValue; } 707 VkQueryControlFlags get_queryFlags() { return m_struct.queryFlags; } 708 void set_queryFlags(VkQueryControlFlags inValue) { m_struct.queryFlags = inValue; } 709 VkQueryPipelineStatisticFlags get_pipelineStatistics() { return m_struct.pipelineStatistics; } 710 void set_pipelineStatistics(VkQueryPipelineStatisticFlags inValue) { m_struct.pipelineStatistics = inValue; } 711 712 713 private: 714 VkCommandBufferInheritanceInfo m_struct; 715 const VkCommandBufferInheritanceInfo* m_origStructAddr; 716 uint32_t m_indent; 717 const char m_dummy_prefix; 718 void display_struct_members(); 719 720 }; 721 722 723 //class declaration 724 class vkcommandpoolcreateinfo_struct_wrapper 725 { 726 public: 727 vkcommandpoolcreateinfo_struct_wrapper(); 728 vkcommandpoolcreateinfo_struct_wrapper(VkCommandPoolCreateInfo* pInStruct); 729 vkcommandpoolcreateinfo_struct_wrapper(const VkCommandPoolCreateInfo* pInStruct); 730 731 virtual ~vkcommandpoolcreateinfo_struct_wrapper(); 732 733 void display_txt(); 734 void display_single_txt(); 735 void display_full_txt(); 736 737 void set_indent(uint32_t indent) { m_indent = indent; } 738 VkStructureType get_sType() { return m_struct.sType; } 739 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 740 const void* get_pNext() { return m_struct.pNext; } 741 VkCommandPoolCreateFlags get_flags() { return m_struct.flags; } 742 void set_flags(VkCommandPoolCreateFlags inValue) { m_struct.flags = inValue; } 743 uint32_t get_queueFamilyIndex() { return m_struct.queueFamilyIndex; } 744 void set_queueFamilyIndex(uint32_t inValue) { m_struct.queueFamilyIndex = inValue; } 745 746 747 private: 748 VkCommandPoolCreateInfo m_struct; 749 const VkCommandPoolCreateInfo* m_origStructAddr; 750 uint32_t m_indent; 751 const char m_dummy_prefix; 752 void display_struct_members(); 753 754 }; 755 756 757 //class declaration 758 class vkcomponentmapping_struct_wrapper 759 { 760 public: 761 vkcomponentmapping_struct_wrapper(); 762 vkcomponentmapping_struct_wrapper(VkComponentMapping* pInStruct); 763 vkcomponentmapping_struct_wrapper(const VkComponentMapping* pInStruct); 764 765 virtual ~vkcomponentmapping_struct_wrapper(); 766 767 void display_txt(); 768 void display_single_txt(); 769 void display_full_txt(); 770 771 void set_indent(uint32_t indent) { m_indent = indent; } 772 VkComponentSwizzle get_r() { return m_struct.r; } 773 void set_r(VkComponentSwizzle inValue) { m_struct.r = inValue; } 774 VkComponentSwizzle get_g() { return m_struct.g; } 775 void set_g(VkComponentSwizzle inValue) { m_struct.g = inValue; } 776 VkComponentSwizzle get_b() { return m_struct.b; } 777 void set_b(VkComponentSwizzle inValue) { m_struct.b = inValue; } 778 VkComponentSwizzle get_a() { return m_struct.a; } 779 void set_a(VkComponentSwizzle inValue) { m_struct.a = inValue; } 780 781 782 private: 783 VkComponentMapping m_struct; 784 const VkComponentMapping* m_origStructAddr; 785 uint32_t m_indent; 786 const char m_dummy_prefix; 787 void display_struct_members(); 788 789 }; 790 791 792 //class declaration 793 class vkcomputepipelinecreateinfo_struct_wrapper 794 { 795 public: 796 vkcomputepipelinecreateinfo_struct_wrapper(); 797 vkcomputepipelinecreateinfo_struct_wrapper(VkComputePipelineCreateInfo* pInStruct); 798 vkcomputepipelinecreateinfo_struct_wrapper(const VkComputePipelineCreateInfo* pInStruct); 799 800 virtual ~vkcomputepipelinecreateinfo_struct_wrapper(); 801 802 void display_txt(); 803 void display_single_txt(); 804 void display_full_txt(); 805 806 void set_indent(uint32_t indent) { m_indent = indent; } 807 VkStructureType get_sType() { return m_struct.sType; } 808 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 809 const void* get_pNext() { return m_struct.pNext; } 810 VkPipelineCreateFlags get_flags() { return m_struct.flags; } 811 void set_flags(VkPipelineCreateFlags inValue) { m_struct.flags = inValue; } 812 VkPipelineShaderStageCreateInfo get_stage() { return m_struct.stage; } 813 void set_stage(VkPipelineShaderStageCreateInfo inValue) { m_struct.stage = inValue; } 814 VkPipelineLayout get_layout() { return m_struct.layout; } 815 void set_layout(VkPipelineLayout inValue) { m_struct.layout = inValue; } 816 VkPipeline get_basePipelineHandle() { return m_struct.basePipelineHandle; } 817 void set_basePipelineHandle(VkPipeline inValue) { m_struct.basePipelineHandle = inValue; } 818 int32_t get_basePipelineIndex() { return m_struct.basePipelineIndex; } 819 void set_basePipelineIndex(int32_t inValue) { m_struct.basePipelineIndex = inValue; } 820 821 822 private: 823 VkComputePipelineCreateInfo m_struct; 824 const VkComputePipelineCreateInfo* m_origStructAddr; 825 uint32_t m_indent; 826 const char m_dummy_prefix; 827 void display_struct_members(); 828 829 }; 830 831 832 //class declaration 833 class vkcopydescriptorset_struct_wrapper 834 { 835 public: 836 vkcopydescriptorset_struct_wrapper(); 837 vkcopydescriptorset_struct_wrapper(VkCopyDescriptorSet* pInStruct); 838 vkcopydescriptorset_struct_wrapper(const VkCopyDescriptorSet* pInStruct); 839 840 virtual ~vkcopydescriptorset_struct_wrapper(); 841 842 void display_txt(); 843 void display_single_txt(); 844 void display_full_txt(); 845 846 void set_indent(uint32_t indent) { m_indent = indent; } 847 VkStructureType get_sType() { return m_struct.sType; } 848 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 849 const void* get_pNext() { return m_struct.pNext; } 850 VkDescriptorSet get_srcSet() { return m_struct.srcSet; } 851 void set_srcSet(VkDescriptorSet inValue) { m_struct.srcSet = inValue; } 852 uint32_t get_srcBinding() { return m_struct.srcBinding; } 853 void set_srcBinding(uint32_t inValue) { m_struct.srcBinding = inValue; } 854 uint32_t get_srcArrayElement() { return m_struct.srcArrayElement; } 855 void set_srcArrayElement(uint32_t inValue) { m_struct.srcArrayElement = inValue; } 856 VkDescriptorSet get_dstSet() { return m_struct.dstSet; } 857 void set_dstSet(VkDescriptorSet inValue) { m_struct.dstSet = inValue; } 858 uint32_t get_dstBinding() { return m_struct.dstBinding; } 859 void set_dstBinding(uint32_t inValue) { m_struct.dstBinding = inValue; } 860 uint32_t get_dstArrayElement() { return m_struct.dstArrayElement; } 861 void set_dstArrayElement(uint32_t inValue) { m_struct.dstArrayElement = inValue; } 862 uint32_t get_descriptorCount() { return m_struct.descriptorCount; } 863 void set_descriptorCount(uint32_t inValue) { m_struct.descriptorCount = inValue; } 864 865 866 private: 867 VkCopyDescriptorSet m_struct; 868 const VkCopyDescriptorSet* m_origStructAddr; 869 uint32_t m_indent; 870 const char m_dummy_prefix; 871 void display_struct_members(); 872 873 }; 874 875 876 //class declaration 877 class vkdebugmarkermarkerinfoext_struct_wrapper 878 { 879 public: 880 vkdebugmarkermarkerinfoext_struct_wrapper(); 881 vkdebugmarkermarkerinfoext_struct_wrapper(VkDebugMarkerMarkerInfoEXT* pInStruct); 882 vkdebugmarkermarkerinfoext_struct_wrapper(const VkDebugMarkerMarkerInfoEXT* pInStruct); 883 884 virtual ~vkdebugmarkermarkerinfoext_struct_wrapper(); 885 886 void display_txt(); 887 void display_single_txt(); 888 void display_full_txt(); 889 890 void set_indent(uint32_t indent) { m_indent = indent; } 891 VkStructureType get_sType() { return m_struct.sType; } 892 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 893 const void* get_pNext() { return m_struct.pNext; } 894 const char* get_pMarkerName() { return m_struct.pMarkerName; } 895 896 897 private: 898 VkDebugMarkerMarkerInfoEXT m_struct; 899 const VkDebugMarkerMarkerInfoEXT* m_origStructAddr; 900 uint32_t m_indent; 901 const char m_dummy_prefix; 902 void display_struct_members(); 903 904 }; 905 906 907 //class declaration 908 class vkdebugmarkerobjectnameinfoext_struct_wrapper 909 { 910 public: 911 vkdebugmarkerobjectnameinfoext_struct_wrapper(); 912 vkdebugmarkerobjectnameinfoext_struct_wrapper(VkDebugMarkerObjectNameInfoEXT* pInStruct); 913 vkdebugmarkerobjectnameinfoext_struct_wrapper(const VkDebugMarkerObjectNameInfoEXT* pInStruct); 914 915 virtual ~vkdebugmarkerobjectnameinfoext_struct_wrapper(); 916 917 void display_txt(); 918 void display_single_txt(); 919 void display_full_txt(); 920 921 void set_indent(uint32_t indent) { m_indent = indent; } 922 VkStructureType get_sType() { return m_struct.sType; } 923 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 924 const void* get_pNext() { return m_struct.pNext; } 925 VkDebugReportObjectTypeEXT get_objectType() { return m_struct.objectType; } 926 void set_objectType(VkDebugReportObjectTypeEXT inValue) { m_struct.objectType = inValue; } 927 uint64_t get_object() { return m_struct.object; } 928 void set_object(uint64_t inValue) { m_struct.object = inValue; } 929 const char* get_pObjectName() { return m_struct.pObjectName; } 930 931 932 private: 933 VkDebugMarkerObjectNameInfoEXT m_struct; 934 const VkDebugMarkerObjectNameInfoEXT* m_origStructAddr; 935 uint32_t m_indent; 936 const char m_dummy_prefix; 937 void display_struct_members(); 938 939 }; 940 941 942 //class declaration 943 class vkdebugmarkerobjecttaginfoext_struct_wrapper 944 { 945 public: 946 vkdebugmarkerobjecttaginfoext_struct_wrapper(); 947 vkdebugmarkerobjecttaginfoext_struct_wrapper(VkDebugMarkerObjectTagInfoEXT* pInStruct); 948 vkdebugmarkerobjecttaginfoext_struct_wrapper(const VkDebugMarkerObjectTagInfoEXT* pInStruct); 949 950 virtual ~vkdebugmarkerobjecttaginfoext_struct_wrapper(); 951 952 void display_txt(); 953 void display_single_txt(); 954 void display_full_txt(); 955 956 void set_indent(uint32_t indent) { m_indent = indent; } 957 VkStructureType get_sType() { return m_struct.sType; } 958 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 959 const void* get_pNext() { return m_struct.pNext; } 960 VkDebugReportObjectTypeEXT get_objectType() { return m_struct.objectType; } 961 void set_objectType(VkDebugReportObjectTypeEXT inValue) { m_struct.objectType = inValue; } 962 uint64_t get_object() { return m_struct.object; } 963 void set_object(uint64_t inValue) { m_struct.object = inValue; } 964 uint64_t get_tagName() { return m_struct.tagName; } 965 void set_tagName(uint64_t inValue) { m_struct.tagName = inValue; } 966 size_t get_tagSize() { return m_struct.tagSize; } 967 void set_tagSize(size_t inValue) { m_struct.tagSize = inValue; } 968 const void* get_pTag() { return m_struct.pTag; } 969 970 971 private: 972 VkDebugMarkerObjectTagInfoEXT m_struct; 973 const VkDebugMarkerObjectTagInfoEXT* m_origStructAddr; 974 uint32_t m_indent; 975 const char m_dummy_prefix; 976 void display_struct_members(); 977 978 }; 979 980 981 //class declaration 982 class vkdebugreportcallbackcreateinfoext_struct_wrapper 983 { 984 public: 985 vkdebugreportcallbackcreateinfoext_struct_wrapper(); 986 vkdebugreportcallbackcreateinfoext_struct_wrapper(VkDebugReportCallbackCreateInfoEXT* pInStruct); 987 vkdebugreportcallbackcreateinfoext_struct_wrapper(const VkDebugReportCallbackCreateInfoEXT* pInStruct); 988 989 virtual ~vkdebugreportcallbackcreateinfoext_struct_wrapper(); 990 991 void display_txt(); 992 void display_single_txt(); 993 void display_full_txt(); 994 995 void set_indent(uint32_t indent) { m_indent = indent; } 996 VkStructureType get_sType() { return m_struct.sType; } 997 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 998 const void* get_pNext() { return m_struct.pNext; } 999 VkDebugReportFlagsEXT get_flags() { return m_struct.flags; } 1000 void set_flags(VkDebugReportFlagsEXT inValue) { m_struct.flags = inValue; } 1001 PFN_vkDebugReportCallbackEXT get_pfnCallback() { return m_struct.pfnCallback; } 1002 void set_pfnCallback(PFN_vkDebugReportCallbackEXT inValue) { m_struct.pfnCallback = inValue; } 1003 void* get_pUserData() { return m_struct.pUserData; } 1004 void set_pUserData(void* inValue) { m_struct.pUserData = inValue; } 1005 1006 1007 private: 1008 VkDebugReportCallbackCreateInfoEXT m_struct; 1009 const VkDebugReportCallbackCreateInfoEXT* m_origStructAddr; 1010 uint32_t m_indent; 1011 const char m_dummy_prefix; 1012 void display_struct_members(); 1013 1014 }; 1015 1016 1017 //class declaration 1018 class vkdescriptorbufferinfo_struct_wrapper 1019 { 1020 public: 1021 vkdescriptorbufferinfo_struct_wrapper(); 1022 vkdescriptorbufferinfo_struct_wrapper(VkDescriptorBufferInfo* pInStruct); 1023 vkdescriptorbufferinfo_struct_wrapper(const VkDescriptorBufferInfo* pInStruct); 1024 1025 virtual ~vkdescriptorbufferinfo_struct_wrapper(); 1026 1027 void display_txt(); 1028 void display_single_txt(); 1029 void display_full_txt(); 1030 1031 void set_indent(uint32_t indent) { m_indent = indent; } 1032 VkBuffer get_buffer() { return m_struct.buffer; } 1033 void set_buffer(VkBuffer inValue) { m_struct.buffer = inValue; } 1034 VkDeviceSize get_offset() { return m_struct.offset; } 1035 void set_offset(VkDeviceSize inValue) { m_struct.offset = inValue; } 1036 VkDeviceSize get_range() { return m_struct.range; } 1037 void set_range(VkDeviceSize inValue) { m_struct.range = inValue; } 1038 1039 1040 private: 1041 VkDescriptorBufferInfo m_struct; 1042 const VkDescriptorBufferInfo* m_origStructAddr; 1043 uint32_t m_indent; 1044 const char m_dummy_prefix; 1045 void display_struct_members(); 1046 1047 }; 1048 1049 1050 //class declaration 1051 class vkdescriptorimageinfo_struct_wrapper 1052 { 1053 public: 1054 vkdescriptorimageinfo_struct_wrapper(); 1055 vkdescriptorimageinfo_struct_wrapper(VkDescriptorImageInfo* pInStruct); 1056 vkdescriptorimageinfo_struct_wrapper(const VkDescriptorImageInfo* pInStruct); 1057 1058 virtual ~vkdescriptorimageinfo_struct_wrapper(); 1059 1060 void display_txt(); 1061 void display_single_txt(); 1062 void display_full_txt(); 1063 1064 void set_indent(uint32_t indent) { m_indent = indent; } 1065 VkSampler get_sampler() { return m_struct.sampler; } 1066 void set_sampler(VkSampler inValue) { m_struct.sampler = inValue; } 1067 VkImageView get_imageView() { return m_struct.imageView; } 1068 void set_imageView(VkImageView inValue) { m_struct.imageView = inValue; } 1069 VkImageLayout get_imageLayout() { return m_struct.imageLayout; } 1070 void set_imageLayout(VkImageLayout inValue) { m_struct.imageLayout = inValue; } 1071 1072 1073 private: 1074 VkDescriptorImageInfo m_struct; 1075 const VkDescriptorImageInfo* m_origStructAddr; 1076 uint32_t m_indent; 1077 const char m_dummy_prefix; 1078 void display_struct_members(); 1079 1080 }; 1081 1082 1083 //class declaration 1084 class vkdescriptorpoolcreateinfo_struct_wrapper 1085 { 1086 public: 1087 vkdescriptorpoolcreateinfo_struct_wrapper(); 1088 vkdescriptorpoolcreateinfo_struct_wrapper(VkDescriptorPoolCreateInfo* pInStruct); 1089 vkdescriptorpoolcreateinfo_struct_wrapper(const VkDescriptorPoolCreateInfo* pInStruct); 1090 1091 virtual ~vkdescriptorpoolcreateinfo_struct_wrapper(); 1092 1093 void display_txt(); 1094 void display_single_txt(); 1095 void display_full_txt(); 1096 1097 void set_indent(uint32_t indent) { m_indent = indent; } 1098 VkStructureType get_sType() { return m_struct.sType; } 1099 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1100 const void* get_pNext() { return m_struct.pNext; } 1101 VkDescriptorPoolCreateFlags get_flags() { return m_struct.flags; } 1102 void set_flags(VkDescriptorPoolCreateFlags inValue) { m_struct.flags = inValue; } 1103 uint32_t get_maxSets() { return m_struct.maxSets; } 1104 void set_maxSets(uint32_t inValue) { m_struct.maxSets = inValue; } 1105 uint32_t get_poolSizeCount() { return m_struct.poolSizeCount; } 1106 void set_poolSizeCount(uint32_t inValue) { m_struct.poolSizeCount = inValue; } 1107 1108 1109 private: 1110 VkDescriptorPoolCreateInfo m_struct; 1111 const VkDescriptorPoolCreateInfo* m_origStructAddr; 1112 uint32_t m_indent; 1113 const char m_dummy_prefix; 1114 void display_struct_members(); 1115 1116 }; 1117 1118 1119 //class declaration 1120 class vkdescriptorpoolsize_struct_wrapper 1121 { 1122 public: 1123 vkdescriptorpoolsize_struct_wrapper(); 1124 vkdescriptorpoolsize_struct_wrapper(VkDescriptorPoolSize* pInStruct); 1125 vkdescriptorpoolsize_struct_wrapper(const VkDescriptorPoolSize* pInStruct); 1126 1127 virtual ~vkdescriptorpoolsize_struct_wrapper(); 1128 1129 void display_txt(); 1130 void display_single_txt(); 1131 void display_full_txt(); 1132 1133 void set_indent(uint32_t indent) { m_indent = indent; } 1134 VkDescriptorType get_type() { return m_struct.type; } 1135 void set_type(VkDescriptorType inValue) { m_struct.type = inValue; } 1136 uint32_t get_descriptorCount() { return m_struct.descriptorCount; } 1137 void set_descriptorCount(uint32_t inValue) { m_struct.descriptorCount = inValue; } 1138 1139 1140 private: 1141 VkDescriptorPoolSize m_struct; 1142 const VkDescriptorPoolSize* m_origStructAddr; 1143 uint32_t m_indent; 1144 const char m_dummy_prefix; 1145 void display_struct_members(); 1146 1147 }; 1148 1149 1150 //class declaration 1151 class vkdescriptorsetallocateinfo_struct_wrapper 1152 { 1153 public: 1154 vkdescriptorsetallocateinfo_struct_wrapper(); 1155 vkdescriptorsetallocateinfo_struct_wrapper(VkDescriptorSetAllocateInfo* pInStruct); 1156 vkdescriptorsetallocateinfo_struct_wrapper(const VkDescriptorSetAllocateInfo* pInStruct); 1157 1158 virtual ~vkdescriptorsetallocateinfo_struct_wrapper(); 1159 1160 void display_txt(); 1161 void display_single_txt(); 1162 void display_full_txt(); 1163 1164 void set_indent(uint32_t indent) { m_indent = indent; } 1165 VkStructureType get_sType() { return m_struct.sType; } 1166 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1167 const void* get_pNext() { return m_struct.pNext; } 1168 VkDescriptorPool get_descriptorPool() { return m_struct.descriptorPool; } 1169 void set_descriptorPool(VkDescriptorPool inValue) { m_struct.descriptorPool = inValue; } 1170 uint32_t get_descriptorSetCount() { return m_struct.descriptorSetCount; } 1171 void set_descriptorSetCount(uint32_t inValue) { m_struct.descriptorSetCount = inValue; } 1172 1173 1174 private: 1175 VkDescriptorSetAllocateInfo m_struct; 1176 const VkDescriptorSetAllocateInfo* m_origStructAddr; 1177 uint32_t m_indent; 1178 const char m_dummy_prefix; 1179 void display_struct_members(); 1180 1181 }; 1182 1183 1184 //class declaration 1185 class vkdescriptorsetlayoutbinding_struct_wrapper 1186 { 1187 public: 1188 vkdescriptorsetlayoutbinding_struct_wrapper(); 1189 vkdescriptorsetlayoutbinding_struct_wrapper(VkDescriptorSetLayoutBinding* pInStruct); 1190 vkdescriptorsetlayoutbinding_struct_wrapper(const VkDescriptorSetLayoutBinding* pInStruct); 1191 1192 virtual ~vkdescriptorsetlayoutbinding_struct_wrapper(); 1193 1194 void display_txt(); 1195 void display_single_txt(); 1196 void display_full_txt(); 1197 1198 void set_indent(uint32_t indent) { m_indent = indent; } 1199 uint32_t get_binding() { return m_struct.binding; } 1200 void set_binding(uint32_t inValue) { m_struct.binding = inValue; } 1201 VkDescriptorType get_descriptorType() { return m_struct.descriptorType; } 1202 void set_descriptorType(VkDescriptorType inValue) { m_struct.descriptorType = inValue; } 1203 uint32_t get_descriptorCount() { return m_struct.descriptorCount; } 1204 void set_descriptorCount(uint32_t inValue) { m_struct.descriptorCount = inValue; } 1205 VkShaderStageFlags get_stageFlags() { return m_struct.stageFlags; } 1206 void set_stageFlags(VkShaderStageFlags inValue) { m_struct.stageFlags = inValue; } 1207 1208 1209 private: 1210 VkDescriptorSetLayoutBinding m_struct; 1211 const VkDescriptorSetLayoutBinding* m_origStructAddr; 1212 uint32_t m_indent; 1213 const char m_dummy_prefix; 1214 void display_struct_members(); 1215 1216 }; 1217 1218 1219 //class declaration 1220 class vkdescriptorsetlayoutcreateinfo_struct_wrapper 1221 { 1222 public: 1223 vkdescriptorsetlayoutcreateinfo_struct_wrapper(); 1224 vkdescriptorsetlayoutcreateinfo_struct_wrapper(VkDescriptorSetLayoutCreateInfo* pInStruct); 1225 vkdescriptorsetlayoutcreateinfo_struct_wrapper(const VkDescriptorSetLayoutCreateInfo* pInStruct); 1226 1227 virtual ~vkdescriptorsetlayoutcreateinfo_struct_wrapper(); 1228 1229 void display_txt(); 1230 void display_single_txt(); 1231 void display_full_txt(); 1232 1233 void set_indent(uint32_t indent) { m_indent = indent; } 1234 VkStructureType get_sType() { return m_struct.sType; } 1235 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1236 const void* get_pNext() { return m_struct.pNext; } 1237 VkDescriptorSetLayoutCreateFlags get_flags() { return m_struct.flags; } 1238 void set_flags(VkDescriptorSetLayoutCreateFlags inValue) { m_struct.flags = inValue; } 1239 uint32_t get_bindingCount() { return m_struct.bindingCount; } 1240 void set_bindingCount(uint32_t inValue) { m_struct.bindingCount = inValue; } 1241 1242 1243 private: 1244 VkDescriptorSetLayoutCreateInfo m_struct; 1245 const VkDescriptorSetLayoutCreateInfo* m_origStructAddr; 1246 uint32_t m_indent; 1247 const char m_dummy_prefix; 1248 void display_struct_members(); 1249 1250 }; 1251 1252 1253 //class declaration 1254 class vkdevicecreateinfo_struct_wrapper 1255 { 1256 public: 1257 vkdevicecreateinfo_struct_wrapper(); 1258 vkdevicecreateinfo_struct_wrapper(VkDeviceCreateInfo* pInStruct); 1259 vkdevicecreateinfo_struct_wrapper(const VkDeviceCreateInfo* pInStruct); 1260 1261 virtual ~vkdevicecreateinfo_struct_wrapper(); 1262 1263 void display_txt(); 1264 void display_single_txt(); 1265 void display_full_txt(); 1266 1267 void set_indent(uint32_t indent) { m_indent = indent; } 1268 VkStructureType get_sType() { return m_struct.sType; } 1269 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1270 const void* get_pNext() { return m_struct.pNext; } 1271 VkDeviceCreateFlags get_flags() { return m_struct.flags; } 1272 void set_flags(VkDeviceCreateFlags inValue) { m_struct.flags = inValue; } 1273 uint32_t get_queueCreateInfoCount() { return m_struct.queueCreateInfoCount; } 1274 void set_queueCreateInfoCount(uint32_t inValue) { m_struct.queueCreateInfoCount = inValue; } 1275 uint32_t get_enabledLayerCount() { return m_struct.enabledLayerCount; } 1276 void set_enabledLayerCount(uint32_t inValue) { m_struct.enabledLayerCount = inValue; } 1277 uint32_t get_enabledExtensionCount() { return m_struct.enabledExtensionCount; } 1278 void set_enabledExtensionCount(uint32_t inValue) { m_struct.enabledExtensionCount = inValue; } 1279 const VkPhysicalDeviceFeatures* get_pEnabledFeatures() { return m_struct.pEnabledFeatures; } 1280 1281 1282 private: 1283 VkDeviceCreateInfo m_struct; 1284 const VkDeviceCreateInfo* m_origStructAddr; 1285 uint32_t m_indent; 1286 const char m_dummy_prefix; 1287 void display_struct_members(); 1288 1289 }; 1290 1291 1292 //class declaration 1293 class vkdevicequeuecreateinfo_struct_wrapper 1294 { 1295 public: 1296 vkdevicequeuecreateinfo_struct_wrapper(); 1297 vkdevicequeuecreateinfo_struct_wrapper(VkDeviceQueueCreateInfo* pInStruct); 1298 vkdevicequeuecreateinfo_struct_wrapper(const VkDeviceQueueCreateInfo* pInStruct); 1299 1300 virtual ~vkdevicequeuecreateinfo_struct_wrapper(); 1301 1302 void display_txt(); 1303 void display_single_txt(); 1304 void display_full_txt(); 1305 1306 void set_indent(uint32_t indent) { m_indent = indent; } 1307 VkStructureType get_sType() { return m_struct.sType; } 1308 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1309 const void* get_pNext() { return m_struct.pNext; } 1310 VkDeviceQueueCreateFlags get_flags() { return m_struct.flags; } 1311 void set_flags(VkDeviceQueueCreateFlags inValue) { m_struct.flags = inValue; } 1312 uint32_t get_queueFamilyIndex() { return m_struct.queueFamilyIndex; } 1313 void set_queueFamilyIndex(uint32_t inValue) { m_struct.queueFamilyIndex = inValue; } 1314 uint32_t get_queueCount() { return m_struct.queueCount; } 1315 void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; } 1316 1317 1318 private: 1319 VkDeviceQueueCreateInfo m_struct; 1320 const VkDeviceQueueCreateInfo* m_origStructAddr; 1321 uint32_t m_indent; 1322 const char m_dummy_prefix; 1323 void display_struct_members(); 1324 1325 }; 1326 1327 1328 //class declaration 1329 class vkdispatchindirectcommand_struct_wrapper 1330 { 1331 public: 1332 vkdispatchindirectcommand_struct_wrapper(); 1333 vkdispatchindirectcommand_struct_wrapper(VkDispatchIndirectCommand* pInStruct); 1334 vkdispatchindirectcommand_struct_wrapper(const VkDispatchIndirectCommand* pInStruct); 1335 1336 virtual ~vkdispatchindirectcommand_struct_wrapper(); 1337 1338 void display_txt(); 1339 void display_single_txt(); 1340 void display_full_txt(); 1341 1342 void set_indent(uint32_t indent) { m_indent = indent; } 1343 uint32_t get_x() { return m_struct.x; } 1344 void set_x(uint32_t inValue) { m_struct.x = inValue; } 1345 uint32_t get_y() { return m_struct.y; } 1346 void set_y(uint32_t inValue) { m_struct.y = inValue; } 1347 uint32_t get_z() { return m_struct.z; } 1348 void set_z(uint32_t inValue) { m_struct.z = inValue; } 1349 1350 1351 private: 1352 VkDispatchIndirectCommand m_struct; 1353 const VkDispatchIndirectCommand* m_origStructAddr; 1354 uint32_t m_indent; 1355 const char m_dummy_prefix; 1356 void display_struct_members(); 1357 1358 }; 1359 1360 1361 //class declaration 1362 class vkdisplaymodecreateinfokhr_struct_wrapper 1363 { 1364 public: 1365 vkdisplaymodecreateinfokhr_struct_wrapper(); 1366 vkdisplaymodecreateinfokhr_struct_wrapper(VkDisplayModeCreateInfoKHR* pInStruct); 1367 vkdisplaymodecreateinfokhr_struct_wrapper(const VkDisplayModeCreateInfoKHR* pInStruct); 1368 1369 virtual ~vkdisplaymodecreateinfokhr_struct_wrapper(); 1370 1371 void display_txt(); 1372 void display_single_txt(); 1373 void display_full_txt(); 1374 1375 void set_indent(uint32_t indent) { m_indent = indent; } 1376 VkStructureType get_sType() { return m_struct.sType; } 1377 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1378 const void* get_pNext() { return m_struct.pNext; } 1379 VkDisplayModeCreateFlagsKHR get_flags() { return m_struct.flags; } 1380 void set_flags(VkDisplayModeCreateFlagsKHR inValue) { m_struct.flags = inValue; } 1381 VkDisplayModeParametersKHR get_parameters() { return m_struct.parameters; } 1382 void set_parameters(VkDisplayModeParametersKHR inValue) { m_struct.parameters = inValue; } 1383 1384 1385 private: 1386 VkDisplayModeCreateInfoKHR m_struct; 1387 const VkDisplayModeCreateInfoKHR* m_origStructAddr; 1388 uint32_t m_indent; 1389 const char m_dummy_prefix; 1390 void display_struct_members(); 1391 1392 }; 1393 1394 1395 //class declaration 1396 class vkdisplaymodeparameterskhr_struct_wrapper 1397 { 1398 public: 1399 vkdisplaymodeparameterskhr_struct_wrapper(); 1400 vkdisplaymodeparameterskhr_struct_wrapper(VkDisplayModeParametersKHR* pInStruct); 1401 vkdisplaymodeparameterskhr_struct_wrapper(const VkDisplayModeParametersKHR* pInStruct); 1402 1403 virtual ~vkdisplaymodeparameterskhr_struct_wrapper(); 1404 1405 void display_txt(); 1406 void display_single_txt(); 1407 void display_full_txt(); 1408 1409 void set_indent(uint32_t indent) { m_indent = indent; } 1410 VkExtent2D get_visibleRegion() { return m_struct.visibleRegion; } 1411 void set_visibleRegion(VkExtent2D inValue) { m_struct.visibleRegion = inValue; } 1412 uint32_t get_refreshRate() { return m_struct.refreshRate; } 1413 void set_refreshRate(uint32_t inValue) { m_struct.refreshRate = inValue; } 1414 1415 1416 private: 1417 VkDisplayModeParametersKHR m_struct; 1418 const VkDisplayModeParametersKHR* m_origStructAddr; 1419 uint32_t m_indent; 1420 const char m_dummy_prefix; 1421 void display_struct_members(); 1422 1423 }; 1424 1425 1426 //class declaration 1427 class vkdisplaymodepropertieskhr_struct_wrapper 1428 { 1429 public: 1430 vkdisplaymodepropertieskhr_struct_wrapper(); 1431 vkdisplaymodepropertieskhr_struct_wrapper(VkDisplayModePropertiesKHR* pInStruct); 1432 vkdisplaymodepropertieskhr_struct_wrapper(const VkDisplayModePropertiesKHR* pInStruct); 1433 1434 virtual ~vkdisplaymodepropertieskhr_struct_wrapper(); 1435 1436 void display_txt(); 1437 void display_single_txt(); 1438 void display_full_txt(); 1439 1440 void set_indent(uint32_t indent) { m_indent = indent; } 1441 VkDisplayModeKHR get_displayMode() { return m_struct.displayMode; } 1442 void set_displayMode(VkDisplayModeKHR inValue) { m_struct.displayMode = inValue; } 1443 VkDisplayModeParametersKHR get_parameters() { return m_struct.parameters; } 1444 void set_parameters(VkDisplayModeParametersKHR inValue) { m_struct.parameters = inValue; } 1445 1446 1447 private: 1448 VkDisplayModePropertiesKHR m_struct; 1449 const VkDisplayModePropertiesKHR* m_origStructAddr; 1450 uint32_t m_indent; 1451 const char m_dummy_prefix; 1452 void display_struct_members(); 1453 1454 }; 1455 1456 1457 //class declaration 1458 class vkdisplayplanecapabilitieskhr_struct_wrapper 1459 { 1460 public: 1461 vkdisplayplanecapabilitieskhr_struct_wrapper(); 1462 vkdisplayplanecapabilitieskhr_struct_wrapper(VkDisplayPlaneCapabilitiesKHR* pInStruct); 1463 vkdisplayplanecapabilitieskhr_struct_wrapper(const VkDisplayPlaneCapabilitiesKHR* pInStruct); 1464 1465 virtual ~vkdisplayplanecapabilitieskhr_struct_wrapper(); 1466 1467 void display_txt(); 1468 void display_single_txt(); 1469 void display_full_txt(); 1470 1471 void set_indent(uint32_t indent) { m_indent = indent; } 1472 VkDisplayPlaneAlphaFlagsKHR get_supportedAlpha() { return m_struct.supportedAlpha; } 1473 void set_supportedAlpha(VkDisplayPlaneAlphaFlagsKHR inValue) { m_struct.supportedAlpha = inValue; } 1474 VkOffset2D get_minSrcPosition() { return m_struct.minSrcPosition; } 1475 void set_minSrcPosition(VkOffset2D inValue) { m_struct.minSrcPosition = inValue; } 1476 VkOffset2D get_maxSrcPosition() { return m_struct.maxSrcPosition; } 1477 void set_maxSrcPosition(VkOffset2D inValue) { m_struct.maxSrcPosition = inValue; } 1478 VkExtent2D get_minSrcExtent() { return m_struct.minSrcExtent; } 1479 void set_minSrcExtent(VkExtent2D inValue) { m_struct.minSrcExtent = inValue; } 1480 VkExtent2D get_maxSrcExtent() { return m_struct.maxSrcExtent; } 1481 void set_maxSrcExtent(VkExtent2D inValue) { m_struct.maxSrcExtent = inValue; } 1482 VkOffset2D get_minDstPosition() { return m_struct.minDstPosition; } 1483 void set_minDstPosition(VkOffset2D inValue) { m_struct.minDstPosition = inValue; } 1484 VkOffset2D get_maxDstPosition() { return m_struct.maxDstPosition; } 1485 void set_maxDstPosition(VkOffset2D inValue) { m_struct.maxDstPosition = inValue; } 1486 VkExtent2D get_minDstExtent() { return m_struct.minDstExtent; } 1487 void set_minDstExtent(VkExtent2D inValue) { m_struct.minDstExtent = inValue; } 1488 VkExtent2D get_maxDstExtent() { return m_struct.maxDstExtent; } 1489 void set_maxDstExtent(VkExtent2D inValue) { m_struct.maxDstExtent = inValue; } 1490 1491 1492 private: 1493 VkDisplayPlaneCapabilitiesKHR m_struct; 1494 const VkDisplayPlaneCapabilitiesKHR* m_origStructAddr; 1495 uint32_t m_indent; 1496 const char m_dummy_prefix; 1497 void display_struct_members(); 1498 1499 }; 1500 1501 1502 //class declaration 1503 class vkdisplayplanepropertieskhr_struct_wrapper 1504 { 1505 public: 1506 vkdisplayplanepropertieskhr_struct_wrapper(); 1507 vkdisplayplanepropertieskhr_struct_wrapper(VkDisplayPlanePropertiesKHR* pInStruct); 1508 vkdisplayplanepropertieskhr_struct_wrapper(const VkDisplayPlanePropertiesKHR* pInStruct); 1509 1510 virtual ~vkdisplayplanepropertieskhr_struct_wrapper(); 1511 1512 void display_txt(); 1513 void display_single_txt(); 1514 void display_full_txt(); 1515 1516 void set_indent(uint32_t indent) { m_indent = indent; } 1517 VkDisplayKHR get_currentDisplay() { return m_struct.currentDisplay; } 1518 void set_currentDisplay(VkDisplayKHR inValue) { m_struct.currentDisplay = inValue; } 1519 uint32_t get_currentStackIndex() { return m_struct.currentStackIndex; } 1520 void set_currentStackIndex(uint32_t inValue) { m_struct.currentStackIndex = inValue; } 1521 1522 1523 private: 1524 VkDisplayPlanePropertiesKHR m_struct; 1525 const VkDisplayPlanePropertiesKHR* m_origStructAddr; 1526 uint32_t m_indent; 1527 const char m_dummy_prefix; 1528 void display_struct_members(); 1529 1530 }; 1531 1532 1533 //class declaration 1534 class vkdisplaypresentinfokhr_struct_wrapper 1535 { 1536 public: 1537 vkdisplaypresentinfokhr_struct_wrapper(); 1538 vkdisplaypresentinfokhr_struct_wrapper(VkDisplayPresentInfoKHR* pInStruct); 1539 vkdisplaypresentinfokhr_struct_wrapper(const VkDisplayPresentInfoKHR* pInStruct); 1540 1541 virtual ~vkdisplaypresentinfokhr_struct_wrapper(); 1542 1543 void display_txt(); 1544 void display_single_txt(); 1545 void display_full_txt(); 1546 1547 void set_indent(uint32_t indent) { m_indent = indent; } 1548 VkStructureType get_sType() { return m_struct.sType; } 1549 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1550 const void* get_pNext() { return m_struct.pNext; } 1551 VkRect2D get_srcRect() { return m_struct.srcRect; } 1552 void set_srcRect(VkRect2D inValue) { m_struct.srcRect = inValue; } 1553 VkRect2D get_dstRect() { return m_struct.dstRect; } 1554 void set_dstRect(VkRect2D inValue) { m_struct.dstRect = inValue; } 1555 VkBool32 get_persistent() { return m_struct.persistent; } 1556 void set_persistent(VkBool32 inValue) { m_struct.persistent = inValue; } 1557 1558 1559 private: 1560 VkDisplayPresentInfoKHR m_struct; 1561 const VkDisplayPresentInfoKHR* m_origStructAddr; 1562 uint32_t m_indent; 1563 const char m_dummy_prefix; 1564 void display_struct_members(); 1565 1566 }; 1567 1568 1569 //class declaration 1570 class vkdisplaypropertieskhr_struct_wrapper 1571 { 1572 public: 1573 vkdisplaypropertieskhr_struct_wrapper(); 1574 vkdisplaypropertieskhr_struct_wrapper(VkDisplayPropertiesKHR* pInStruct); 1575 vkdisplaypropertieskhr_struct_wrapper(const VkDisplayPropertiesKHR* pInStruct); 1576 1577 virtual ~vkdisplaypropertieskhr_struct_wrapper(); 1578 1579 void display_txt(); 1580 void display_single_txt(); 1581 void display_full_txt(); 1582 1583 void set_indent(uint32_t indent) { m_indent = indent; } 1584 VkDisplayKHR get_display() { return m_struct.display; } 1585 void set_display(VkDisplayKHR inValue) { m_struct.display = inValue; } 1586 const char* get_displayName() { return m_struct.displayName; } 1587 VkExtent2D get_physicalDimensions() { return m_struct.physicalDimensions; } 1588 void set_physicalDimensions(VkExtent2D inValue) { m_struct.physicalDimensions = inValue; } 1589 VkExtent2D get_physicalResolution() { return m_struct.physicalResolution; } 1590 void set_physicalResolution(VkExtent2D inValue) { m_struct.physicalResolution = inValue; } 1591 VkSurfaceTransformFlagsKHR get_supportedTransforms() { return m_struct.supportedTransforms; } 1592 void set_supportedTransforms(VkSurfaceTransformFlagsKHR inValue) { m_struct.supportedTransforms = inValue; } 1593 VkBool32 get_planeReorderPossible() { return m_struct.planeReorderPossible; } 1594 void set_planeReorderPossible(VkBool32 inValue) { m_struct.planeReorderPossible = inValue; } 1595 VkBool32 get_persistentContent() { return m_struct.persistentContent; } 1596 void set_persistentContent(VkBool32 inValue) { m_struct.persistentContent = inValue; } 1597 1598 1599 private: 1600 VkDisplayPropertiesKHR m_struct; 1601 const VkDisplayPropertiesKHR* m_origStructAddr; 1602 uint32_t m_indent; 1603 const char m_dummy_prefix; 1604 void display_struct_members(); 1605 1606 }; 1607 1608 1609 //class declaration 1610 class vkdisplaysurfacecreateinfokhr_struct_wrapper 1611 { 1612 public: 1613 vkdisplaysurfacecreateinfokhr_struct_wrapper(); 1614 vkdisplaysurfacecreateinfokhr_struct_wrapper(VkDisplaySurfaceCreateInfoKHR* pInStruct); 1615 vkdisplaysurfacecreateinfokhr_struct_wrapper(const VkDisplaySurfaceCreateInfoKHR* pInStruct); 1616 1617 virtual ~vkdisplaysurfacecreateinfokhr_struct_wrapper(); 1618 1619 void display_txt(); 1620 void display_single_txt(); 1621 void display_full_txt(); 1622 1623 void set_indent(uint32_t indent) { m_indent = indent; } 1624 VkStructureType get_sType() { return m_struct.sType; } 1625 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1626 const void* get_pNext() { return m_struct.pNext; } 1627 VkDisplaySurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 1628 void set_flags(VkDisplaySurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 1629 VkDisplayModeKHR get_displayMode() { return m_struct.displayMode; } 1630 void set_displayMode(VkDisplayModeKHR inValue) { m_struct.displayMode = inValue; } 1631 uint32_t get_planeIndex() { return m_struct.planeIndex; } 1632 void set_planeIndex(uint32_t inValue) { m_struct.planeIndex = inValue; } 1633 uint32_t get_planeStackIndex() { return m_struct.planeStackIndex; } 1634 void set_planeStackIndex(uint32_t inValue) { m_struct.planeStackIndex = inValue; } 1635 VkSurfaceTransformFlagBitsKHR get_transform() { return m_struct.transform; } 1636 void set_transform(VkSurfaceTransformFlagBitsKHR inValue) { m_struct.transform = inValue; } 1637 float get_globalAlpha() { return m_struct.globalAlpha; } 1638 void set_globalAlpha(float inValue) { m_struct.globalAlpha = inValue; } 1639 VkDisplayPlaneAlphaFlagBitsKHR get_alphaMode() { return m_struct.alphaMode; } 1640 void set_alphaMode(VkDisplayPlaneAlphaFlagBitsKHR inValue) { m_struct.alphaMode = inValue; } 1641 VkExtent2D get_imageExtent() { return m_struct.imageExtent; } 1642 void set_imageExtent(VkExtent2D inValue) { m_struct.imageExtent = inValue; } 1643 1644 1645 private: 1646 VkDisplaySurfaceCreateInfoKHR m_struct; 1647 const VkDisplaySurfaceCreateInfoKHR* m_origStructAddr; 1648 uint32_t m_indent; 1649 const char m_dummy_prefix; 1650 void display_struct_members(); 1651 1652 }; 1653 1654 1655 //class declaration 1656 class vkdrawindexedindirectcommand_struct_wrapper 1657 { 1658 public: 1659 vkdrawindexedindirectcommand_struct_wrapper(); 1660 vkdrawindexedindirectcommand_struct_wrapper(VkDrawIndexedIndirectCommand* pInStruct); 1661 vkdrawindexedindirectcommand_struct_wrapper(const VkDrawIndexedIndirectCommand* pInStruct); 1662 1663 virtual ~vkdrawindexedindirectcommand_struct_wrapper(); 1664 1665 void display_txt(); 1666 void display_single_txt(); 1667 void display_full_txt(); 1668 1669 void set_indent(uint32_t indent) { m_indent = indent; } 1670 uint32_t get_indexCount() { return m_struct.indexCount; } 1671 void set_indexCount(uint32_t inValue) { m_struct.indexCount = inValue; } 1672 uint32_t get_instanceCount() { return m_struct.instanceCount; } 1673 void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; } 1674 uint32_t get_firstIndex() { return m_struct.firstIndex; } 1675 void set_firstIndex(uint32_t inValue) { m_struct.firstIndex = inValue; } 1676 int32_t get_vertexOffset() { return m_struct.vertexOffset; } 1677 void set_vertexOffset(int32_t inValue) { m_struct.vertexOffset = inValue; } 1678 uint32_t get_firstInstance() { return m_struct.firstInstance; } 1679 void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; } 1680 1681 1682 private: 1683 VkDrawIndexedIndirectCommand m_struct; 1684 const VkDrawIndexedIndirectCommand* m_origStructAddr; 1685 uint32_t m_indent; 1686 const char m_dummy_prefix; 1687 void display_struct_members(); 1688 1689 }; 1690 1691 1692 //class declaration 1693 class vkdrawindirectcommand_struct_wrapper 1694 { 1695 public: 1696 vkdrawindirectcommand_struct_wrapper(); 1697 vkdrawindirectcommand_struct_wrapper(VkDrawIndirectCommand* pInStruct); 1698 vkdrawindirectcommand_struct_wrapper(const VkDrawIndirectCommand* pInStruct); 1699 1700 virtual ~vkdrawindirectcommand_struct_wrapper(); 1701 1702 void display_txt(); 1703 void display_single_txt(); 1704 void display_full_txt(); 1705 1706 void set_indent(uint32_t indent) { m_indent = indent; } 1707 uint32_t get_vertexCount() { return m_struct.vertexCount; } 1708 void set_vertexCount(uint32_t inValue) { m_struct.vertexCount = inValue; } 1709 uint32_t get_instanceCount() { return m_struct.instanceCount; } 1710 void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; } 1711 uint32_t get_firstVertex() { return m_struct.firstVertex; } 1712 void set_firstVertex(uint32_t inValue) { m_struct.firstVertex = inValue; } 1713 uint32_t get_firstInstance() { return m_struct.firstInstance; } 1714 void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; } 1715 1716 1717 private: 1718 VkDrawIndirectCommand m_struct; 1719 const VkDrawIndirectCommand* m_origStructAddr; 1720 uint32_t m_indent; 1721 const char m_dummy_prefix; 1722 void display_struct_members(); 1723 1724 }; 1725 1726 1727 //class declaration 1728 class vkeventcreateinfo_struct_wrapper 1729 { 1730 public: 1731 vkeventcreateinfo_struct_wrapper(); 1732 vkeventcreateinfo_struct_wrapper(VkEventCreateInfo* pInStruct); 1733 vkeventcreateinfo_struct_wrapper(const VkEventCreateInfo* pInStruct); 1734 1735 virtual ~vkeventcreateinfo_struct_wrapper(); 1736 1737 void display_txt(); 1738 void display_single_txt(); 1739 void display_full_txt(); 1740 1741 void set_indent(uint32_t indent) { m_indent = indent; } 1742 VkStructureType get_sType() { return m_struct.sType; } 1743 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1744 const void* get_pNext() { return m_struct.pNext; } 1745 VkEventCreateFlags get_flags() { return m_struct.flags; } 1746 void set_flags(VkEventCreateFlags inValue) { m_struct.flags = inValue; } 1747 1748 1749 private: 1750 VkEventCreateInfo m_struct; 1751 const VkEventCreateInfo* m_origStructAddr; 1752 uint32_t m_indent; 1753 const char m_dummy_prefix; 1754 void display_struct_members(); 1755 1756 }; 1757 1758 1759 //class declaration 1760 class vkextensionproperties_struct_wrapper 1761 { 1762 public: 1763 vkextensionproperties_struct_wrapper(); 1764 vkextensionproperties_struct_wrapper(VkExtensionProperties* pInStruct); 1765 vkextensionproperties_struct_wrapper(const VkExtensionProperties* pInStruct); 1766 1767 virtual ~vkextensionproperties_struct_wrapper(); 1768 1769 void display_txt(); 1770 void display_single_txt(); 1771 void display_full_txt(); 1772 1773 void set_indent(uint32_t indent) { m_indent = indent; } 1774 uint32_t get_specVersion() { return m_struct.specVersion; } 1775 void set_specVersion(uint32_t inValue) { m_struct.specVersion = inValue; } 1776 1777 1778 private: 1779 VkExtensionProperties m_struct; 1780 const VkExtensionProperties* m_origStructAddr; 1781 uint32_t m_indent; 1782 const char m_dummy_prefix; 1783 void display_struct_members(); 1784 1785 }; 1786 1787 1788 //class declaration 1789 class vkextent2d_struct_wrapper 1790 { 1791 public: 1792 vkextent2d_struct_wrapper(); 1793 vkextent2d_struct_wrapper(VkExtent2D* pInStruct); 1794 vkextent2d_struct_wrapper(const VkExtent2D* pInStruct); 1795 1796 virtual ~vkextent2d_struct_wrapper(); 1797 1798 void display_txt(); 1799 void display_single_txt(); 1800 void display_full_txt(); 1801 1802 void set_indent(uint32_t indent) { m_indent = indent; } 1803 uint32_t get_width() { return m_struct.width; } 1804 void set_width(uint32_t inValue) { m_struct.width = inValue; } 1805 uint32_t get_height() { return m_struct.height; } 1806 void set_height(uint32_t inValue) { m_struct.height = inValue; } 1807 1808 1809 private: 1810 VkExtent2D m_struct; 1811 const VkExtent2D* m_origStructAddr; 1812 uint32_t m_indent; 1813 const char m_dummy_prefix; 1814 void display_struct_members(); 1815 1816 }; 1817 1818 1819 //class declaration 1820 class vkextent3d_struct_wrapper 1821 { 1822 public: 1823 vkextent3d_struct_wrapper(); 1824 vkextent3d_struct_wrapper(VkExtent3D* pInStruct); 1825 vkextent3d_struct_wrapper(const VkExtent3D* pInStruct); 1826 1827 virtual ~vkextent3d_struct_wrapper(); 1828 1829 void display_txt(); 1830 void display_single_txt(); 1831 void display_full_txt(); 1832 1833 void set_indent(uint32_t indent) { m_indent = indent; } 1834 uint32_t get_width() { return m_struct.width; } 1835 void set_width(uint32_t inValue) { m_struct.width = inValue; } 1836 uint32_t get_height() { return m_struct.height; } 1837 void set_height(uint32_t inValue) { m_struct.height = inValue; } 1838 uint32_t get_depth() { return m_struct.depth; } 1839 void set_depth(uint32_t inValue) { m_struct.depth = inValue; } 1840 1841 1842 private: 1843 VkExtent3D m_struct; 1844 const VkExtent3D* m_origStructAddr; 1845 uint32_t m_indent; 1846 const char m_dummy_prefix; 1847 void display_struct_members(); 1848 1849 }; 1850 1851 1852 //class declaration 1853 class vkfencecreateinfo_struct_wrapper 1854 { 1855 public: 1856 vkfencecreateinfo_struct_wrapper(); 1857 vkfencecreateinfo_struct_wrapper(VkFenceCreateInfo* pInStruct); 1858 vkfencecreateinfo_struct_wrapper(const VkFenceCreateInfo* pInStruct); 1859 1860 virtual ~vkfencecreateinfo_struct_wrapper(); 1861 1862 void display_txt(); 1863 void display_single_txt(); 1864 void display_full_txt(); 1865 1866 void set_indent(uint32_t indent) { m_indent = indent; } 1867 VkStructureType get_sType() { return m_struct.sType; } 1868 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1869 const void* get_pNext() { return m_struct.pNext; } 1870 VkFenceCreateFlags get_flags() { return m_struct.flags; } 1871 void set_flags(VkFenceCreateFlags inValue) { m_struct.flags = inValue; } 1872 1873 1874 private: 1875 VkFenceCreateInfo m_struct; 1876 const VkFenceCreateInfo* m_origStructAddr; 1877 uint32_t m_indent; 1878 const char m_dummy_prefix; 1879 void display_struct_members(); 1880 1881 }; 1882 1883 1884 //class declaration 1885 class vkformatproperties_struct_wrapper 1886 { 1887 public: 1888 vkformatproperties_struct_wrapper(); 1889 vkformatproperties_struct_wrapper(VkFormatProperties* pInStruct); 1890 vkformatproperties_struct_wrapper(const VkFormatProperties* pInStruct); 1891 1892 virtual ~vkformatproperties_struct_wrapper(); 1893 1894 void display_txt(); 1895 void display_single_txt(); 1896 void display_full_txt(); 1897 1898 void set_indent(uint32_t indent) { m_indent = indent; } 1899 VkFormatFeatureFlags get_linearTilingFeatures() { return m_struct.linearTilingFeatures; } 1900 void set_linearTilingFeatures(VkFormatFeatureFlags inValue) { m_struct.linearTilingFeatures = inValue; } 1901 VkFormatFeatureFlags get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; } 1902 void set_optimalTilingFeatures(VkFormatFeatureFlags inValue) { m_struct.optimalTilingFeatures = inValue; } 1903 VkFormatFeatureFlags get_bufferFeatures() { return m_struct.bufferFeatures; } 1904 void set_bufferFeatures(VkFormatFeatureFlags inValue) { m_struct.bufferFeatures = inValue; } 1905 1906 1907 private: 1908 VkFormatProperties m_struct; 1909 const VkFormatProperties* m_origStructAddr; 1910 uint32_t m_indent; 1911 const char m_dummy_prefix; 1912 void display_struct_members(); 1913 1914 }; 1915 1916 1917 //class declaration 1918 class vkframebuffercreateinfo_struct_wrapper 1919 { 1920 public: 1921 vkframebuffercreateinfo_struct_wrapper(); 1922 vkframebuffercreateinfo_struct_wrapper(VkFramebufferCreateInfo* pInStruct); 1923 vkframebuffercreateinfo_struct_wrapper(const VkFramebufferCreateInfo* pInStruct); 1924 1925 virtual ~vkframebuffercreateinfo_struct_wrapper(); 1926 1927 void display_txt(); 1928 void display_single_txt(); 1929 void display_full_txt(); 1930 1931 void set_indent(uint32_t indent) { m_indent = indent; } 1932 VkStructureType get_sType() { return m_struct.sType; } 1933 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1934 const void* get_pNext() { return m_struct.pNext; } 1935 VkFramebufferCreateFlags get_flags() { return m_struct.flags; } 1936 void set_flags(VkFramebufferCreateFlags inValue) { m_struct.flags = inValue; } 1937 VkRenderPass get_renderPass() { return m_struct.renderPass; } 1938 void set_renderPass(VkRenderPass inValue) { m_struct.renderPass = inValue; } 1939 uint32_t get_attachmentCount() { return m_struct.attachmentCount; } 1940 void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; } 1941 uint32_t get_width() { return m_struct.width; } 1942 void set_width(uint32_t inValue) { m_struct.width = inValue; } 1943 uint32_t get_height() { return m_struct.height; } 1944 void set_height(uint32_t inValue) { m_struct.height = inValue; } 1945 uint32_t get_layers() { return m_struct.layers; } 1946 void set_layers(uint32_t inValue) { m_struct.layers = inValue; } 1947 1948 1949 private: 1950 VkFramebufferCreateInfo m_struct; 1951 const VkFramebufferCreateInfo* m_origStructAddr; 1952 uint32_t m_indent; 1953 const char m_dummy_prefix; 1954 void display_struct_members(); 1955 1956 }; 1957 1958 1959 //class declaration 1960 class vkgraphicspipelinecreateinfo_struct_wrapper 1961 { 1962 public: 1963 vkgraphicspipelinecreateinfo_struct_wrapper(); 1964 vkgraphicspipelinecreateinfo_struct_wrapper(VkGraphicsPipelineCreateInfo* pInStruct); 1965 vkgraphicspipelinecreateinfo_struct_wrapper(const VkGraphicsPipelineCreateInfo* pInStruct); 1966 1967 virtual ~vkgraphicspipelinecreateinfo_struct_wrapper(); 1968 1969 void display_txt(); 1970 void display_single_txt(); 1971 void display_full_txt(); 1972 1973 void set_indent(uint32_t indent) { m_indent = indent; } 1974 VkStructureType get_sType() { return m_struct.sType; } 1975 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1976 const void* get_pNext() { return m_struct.pNext; } 1977 VkPipelineCreateFlags get_flags() { return m_struct.flags; } 1978 void set_flags(VkPipelineCreateFlags inValue) { m_struct.flags = inValue; } 1979 uint32_t get_stageCount() { return m_struct.stageCount; } 1980 void set_stageCount(uint32_t inValue) { m_struct.stageCount = inValue; } 1981 const VkPipelineVertexInputStateCreateInfo* get_pVertexInputState() { return m_struct.pVertexInputState; } 1982 const VkPipelineInputAssemblyStateCreateInfo* get_pInputAssemblyState() { return m_struct.pInputAssemblyState; } 1983 const VkPipelineTessellationStateCreateInfo* get_pTessellationState() { return m_struct.pTessellationState; } 1984 const VkPipelineViewportStateCreateInfo* get_pViewportState() { return m_struct.pViewportState; } 1985 const VkPipelineRasterizationStateCreateInfo* get_pRasterizationState() { return m_struct.pRasterizationState; } 1986 const VkPipelineMultisampleStateCreateInfo* get_pMultisampleState() { return m_struct.pMultisampleState; } 1987 const VkPipelineDepthStencilStateCreateInfo* get_pDepthStencilState() { return m_struct.pDepthStencilState; } 1988 const VkPipelineColorBlendStateCreateInfo* get_pColorBlendState() { return m_struct.pColorBlendState; } 1989 const VkPipelineDynamicStateCreateInfo* get_pDynamicState() { return m_struct.pDynamicState; } 1990 VkPipelineLayout get_layout() { return m_struct.layout; } 1991 void set_layout(VkPipelineLayout inValue) { m_struct.layout = inValue; } 1992 VkRenderPass get_renderPass() { return m_struct.renderPass; } 1993 void set_renderPass(VkRenderPass inValue) { m_struct.renderPass = inValue; } 1994 uint32_t get_subpass() { return m_struct.subpass; } 1995 void set_subpass(uint32_t inValue) { m_struct.subpass = inValue; } 1996 VkPipeline get_basePipelineHandle() { return m_struct.basePipelineHandle; } 1997 void set_basePipelineHandle(VkPipeline inValue) { m_struct.basePipelineHandle = inValue; } 1998 int32_t get_basePipelineIndex() { return m_struct.basePipelineIndex; } 1999 void set_basePipelineIndex(int32_t inValue) { m_struct.basePipelineIndex = inValue; } 2000 2001 2002 private: 2003 VkGraphicsPipelineCreateInfo m_struct; 2004 const VkGraphicsPipelineCreateInfo* m_origStructAddr; 2005 uint32_t m_indent; 2006 const char m_dummy_prefix; 2007 void display_struct_members(); 2008 2009 }; 2010 2011 2012 //class declaration 2013 class vkimageblit_struct_wrapper 2014 { 2015 public: 2016 vkimageblit_struct_wrapper(); 2017 vkimageblit_struct_wrapper(VkImageBlit* pInStruct); 2018 vkimageblit_struct_wrapper(const VkImageBlit* pInStruct); 2019 2020 virtual ~vkimageblit_struct_wrapper(); 2021 2022 void display_txt(); 2023 void display_single_txt(); 2024 void display_full_txt(); 2025 2026 void set_indent(uint32_t indent) { m_indent = indent; } 2027 VkImageSubresourceLayers get_srcSubresource() { return m_struct.srcSubresource; } 2028 void set_srcSubresource(VkImageSubresourceLayers inValue) { m_struct.srcSubresource = inValue; } 2029 VkImageSubresourceLayers get_dstSubresource() { return m_struct.dstSubresource; } 2030 void set_dstSubresource(VkImageSubresourceLayers inValue) { m_struct.dstSubresource = inValue; } 2031 2032 2033 private: 2034 VkImageBlit m_struct; 2035 const VkImageBlit* m_origStructAddr; 2036 uint32_t m_indent; 2037 const char m_dummy_prefix; 2038 void display_struct_members(); 2039 2040 }; 2041 2042 2043 //class declaration 2044 class vkimagecopy_struct_wrapper 2045 { 2046 public: 2047 vkimagecopy_struct_wrapper(); 2048 vkimagecopy_struct_wrapper(VkImageCopy* pInStruct); 2049 vkimagecopy_struct_wrapper(const VkImageCopy* pInStruct); 2050 2051 virtual ~vkimagecopy_struct_wrapper(); 2052 2053 void display_txt(); 2054 void display_single_txt(); 2055 void display_full_txt(); 2056 2057 void set_indent(uint32_t indent) { m_indent = indent; } 2058 VkImageSubresourceLayers get_srcSubresource() { return m_struct.srcSubresource; } 2059 void set_srcSubresource(VkImageSubresourceLayers inValue) { m_struct.srcSubresource = inValue; } 2060 VkOffset3D get_srcOffset() { return m_struct.srcOffset; } 2061 void set_srcOffset(VkOffset3D inValue) { m_struct.srcOffset = inValue; } 2062 VkImageSubresourceLayers get_dstSubresource() { return m_struct.dstSubresource; } 2063 void set_dstSubresource(VkImageSubresourceLayers inValue) { m_struct.dstSubresource = inValue; } 2064 VkOffset3D get_dstOffset() { return m_struct.dstOffset; } 2065 void set_dstOffset(VkOffset3D inValue) { m_struct.dstOffset = inValue; } 2066 VkExtent3D get_extent() { return m_struct.extent; } 2067 void set_extent(VkExtent3D inValue) { m_struct.extent = inValue; } 2068 2069 2070 private: 2071 VkImageCopy m_struct; 2072 const VkImageCopy* m_origStructAddr; 2073 uint32_t m_indent; 2074 const char m_dummy_prefix; 2075 void display_struct_members(); 2076 2077 }; 2078 2079 2080 //class declaration 2081 class vkimagecreateinfo_struct_wrapper 2082 { 2083 public: 2084 vkimagecreateinfo_struct_wrapper(); 2085 vkimagecreateinfo_struct_wrapper(VkImageCreateInfo* pInStruct); 2086 vkimagecreateinfo_struct_wrapper(const VkImageCreateInfo* pInStruct); 2087 2088 virtual ~vkimagecreateinfo_struct_wrapper(); 2089 2090 void display_txt(); 2091 void display_single_txt(); 2092 void display_full_txt(); 2093 2094 void set_indent(uint32_t indent) { m_indent = indent; } 2095 VkStructureType get_sType() { return m_struct.sType; } 2096 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2097 const void* get_pNext() { return m_struct.pNext; } 2098 VkImageCreateFlags get_flags() { return m_struct.flags; } 2099 void set_flags(VkImageCreateFlags inValue) { m_struct.flags = inValue; } 2100 VkImageType get_imageType() { return m_struct.imageType; } 2101 void set_imageType(VkImageType inValue) { m_struct.imageType = inValue; } 2102 VkFormat get_format() { return m_struct.format; } 2103 void set_format(VkFormat inValue) { m_struct.format = inValue; } 2104 VkExtent3D get_extent() { return m_struct.extent; } 2105 void set_extent(VkExtent3D inValue) { m_struct.extent = inValue; } 2106 uint32_t get_mipLevels() { return m_struct.mipLevels; } 2107 void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; } 2108 uint32_t get_arrayLayers() { return m_struct.arrayLayers; } 2109 void set_arrayLayers(uint32_t inValue) { m_struct.arrayLayers = inValue; } 2110 VkSampleCountFlagBits get_samples() { return m_struct.samples; } 2111 void set_samples(VkSampleCountFlagBits inValue) { m_struct.samples = inValue; } 2112 VkImageTiling get_tiling() { return m_struct.tiling; } 2113 void set_tiling(VkImageTiling inValue) { m_struct.tiling = inValue; } 2114 VkImageUsageFlags get_usage() { return m_struct.usage; } 2115 void set_usage(VkImageUsageFlags inValue) { m_struct.usage = inValue; } 2116 VkSharingMode get_sharingMode() { return m_struct.sharingMode; } 2117 void set_sharingMode(VkSharingMode inValue) { m_struct.sharingMode = inValue; } 2118 uint32_t get_queueFamilyIndexCount() { return m_struct.queueFamilyIndexCount; } 2119 void set_queueFamilyIndexCount(uint32_t inValue) { m_struct.queueFamilyIndexCount = inValue; } 2120 VkImageLayout get_initialLayout() { return m_struct.initialLayout; } 2121 void set_initialLayout(VkImageLayout inValue) { m_struct.initialLayout = inValue; } 2122 2123 2124 private: 2125 VkImageCreateInfo m_struct; 2126 const VkImageCreateInfo* m_origStructAddr; 2127 uint32_t m_indent; 2128 const char m_dummy_prefix; 2129 void display_struct_members(); 2130 2131 }; 2132 2133 2134 //class declaration 2135 class vkimageformatproperties_struct_wrapper 2136 { 2137 public: 2138 vkimageformatproperties_struct_wrapper(); 2139 vkimageformatproperties_struct_wrapper(VkImageFormatProperties* pInStruct); 2140 vkimageformatproperties_struct_wrapper(const VkImageFormatProperties* pInStruct); 2141 2142 virtual ~vkimageformatproperties_struct_wrapper(); 2143 2144 void display_txt(); 2145 void display_single_txt(); 2146 void display_full_txt(); 2147 2148 void set_indent(uint32_t indent) { m_indent = indent; } 2149 VkExtent3D get_maxExtent() { return m_struct.maxExtent; } 2150 void set_maxExtent(VkExtent3D inValue) { m_struct.maxExtent = inValue; } 2151 uint32_t get_maxMipLevels() { return m_struct.maxMipLevels; } 2152 void set_maxMipLevels(uint32_t inValue) { m_struct.maxMipLevels = inValue; } 2153 uint32_t get_maxArrayLayers() { return m_struct.maxArrayLayers; } 2154 void set_maxArrayLayers(uint32_t inValue) { m_struct.maxArrayLayers = inValue; } 2155 VkSampleCountFlags get_sampleCounts() { return m_struct.sampleCounts; } 2156 void set_sampleCounts(VkSampleCountFlags inValue) { m_struct.sampleCounts = inValue; } 2157 VkDeviceSize get_maxResourceSize() { return m_struct.maxResourceSize; } 2158 void set_maxResourceSize(VkDeviceSize inValue) { m_struct.maxResourceSize = inValue; } 2159 2160 2161 private: 2162 VkImageFormatProperties m_struct; 2163 const VkImageFormatProperties* m_origStructAddr; 2164 uint32_t m_indent; 2165 const char m_dummy_prefix; 2166 void display_struct_members(); 2167 2168 }; 2169 2170 2171 //class declaration 2172 class vkimagememorybarrier_struct_wrapper 2173 { 2174 public: 2175 vkimagememorybarrier_struct_wrapper(); 2176 vkimagememorybarrier_struct_wrapper(VkImageMemoryBarrier* pInStruct); 2177 vkimagememorybarrier_struct_wrapper(const VkImageMemoryBarrier* pInStruct); 2178 2179 virtual ~vkimagememorybarrier_struct_wrapper(); 2180 2181 void display_txt(); 2182 void display_single_txt(); 2183 void display_full_txt(); 2184 2185 void set_indent(uint32_t indent) { m_indent = indent; } 2186 VkStructureType get_sType() { return m_struct.sType; } 2187 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2188 const void* get_pNext() { return m_struct.pNext; } 2189 VkAccessFlags get_srcAccessMask() { return m_struct.srcAccessMask; } 2190 void set_srcAccessMask(VkAccessFlags inValue) { m_struct.srcAccessMask = inValue; } 2191 VkAccessFlags get_dstAccessMask() { return m_struct.dstAccessMask; } 2192 void set_dstAccessMask(VkAccessFlags inValue) { m_struct.dstAccessMask = inValue; } 2193 VkImageLayout get_oldLayout() { return m_struct.oldLayout; } 2194 void set_oldLayout(VkImageLayout inValue) { m_struct.oldLayout = inValue; } 2195 VkImageLayout get_newLayout() { return m_struct.newLayout; } 2196 void set_newLayout(VkImageLayout inValue) { m_struct.newLayout = inValue; } 2197 uint32_t get_srcQueueFamilyIndex() { return m_struct.srcQueueFamilyIndex; } 2198 void set_srcQueueFamilyIndex(uint32_t inValue) { m_struct.srcQueueFamilyIndex = inValue; } 2199 uint32_t get_dstQueueFamilyIndex() { return m_struct.dstQueueFamilyIndex; } 2200 void set_dstQueueFamilyIndex(uint32_t inValue) { m_struct.dstQueueFamilyIndex = inValue; } 2201 VkImage get_image() { return m_struct.image; } 2202 void set_image(VkImage inValue) { m_struct.image = inValue; } 2203 VkImageSubresourceRange get_subresourceRange() { return m_struct.subresourceRange; } 2204 void set_subresourceRange(VkImageSubresourceRange inValue) { m_struct.subresourceRange = inValue; } 2205 2206 2207 private: 2208 VkImageMemoryBarrier m_struct; 2209 const VkImageMemoryBarrier* m_origStructAddr; 2210 uint32_t m_indent; 2211 const char m_dummy_prefix; 2212 void display_struct_members(); 2213 2214 }; 2215 2216 2217 //class declaration 2218 class vkimageresolve_struct_wrapper 2219 { 2220 public: 2221 vkimageresolve_struct_wrapper(); 2222 vkimageresolve_struct_wrapper(VkImageResolve* pInStruct); 2223 vkimageresolve_struct_wrapper(const VkImageResolve* pInStruct); 2224 2225 virtual ~vkimageresolve_struct_wrapper(); 2226 2227 void display_txt(); 2228 void display_single_txt(); 2229 void display_full_txt(); 2230 2231 void set_indent(uint32_t indent) { m_indent = indent; } 2232 VkImageSubresourceLayers get_srcSubresource() { return m_struct.srcSubresource; } 2233 void set_srcSubresource(VkImageSubresourceLayers inValue) { m_struct.srcSubresource = inValue; } 2234 VkOffset3D get_srcOffset() { return m_struct.srcOffset; } 2235 void set_srcOffset(VkOffset3D inValue) { m_struct.srcOffset = inValue; } 2236 VkImageSubresourceLayers get_dstSubresource() { return m_struct.dstSubresource; } 2237 void set_dstSubresource(VkImageSubresourceLayers inValue) { m_struct.dstSubresource = inValue; } 2238 VkOffset3D get_dstOffset() { return m_struct.dstOffset; } 2239 void set_dstOffset(VkOffset3D inValue) { m_struct.dstOffset = inValue; } 2240 VkExtent3D get_extent() { return m_struct.extent; } 2241 void set_extent(VkExtent3D inValue) { m_struct.extent = inValue; } 2242 2243 2244 private: 2245 VkImageResolve m_struct; 2246 const VkImageResolve* m_origStructAddr; 2247 uint32_t m_indent; 2248 const char m_dummy_prefix; 2249 void display_struct_members(); 2250 2251 }; 2252 2253 2254 //class declaration 2255 class vkimagesubresource_struct_wrapper 2256 { 2257 public: 2258 vkimagesubresource_struct_wrapper(); 2259 vkimagesubresource_struct_wrapper(VkImageSubresource* pInStruct); 2260 vkimagesubresource_struct_wrapper(const VkImageSubresource* pInStruct); 2261 2262 virtual ~vkimagesubresource_struct_wrapper(); 2263 2264 void display_txt(); 2265 void display_single_txt(); 2266 void display_full_txt(); 2267 2268 void set_indent(uint32_t indent) { m_indent = indent; } 2269 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 2270 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 2271 uint32_t get_mipLevel() { return m_struct.mipLevel; } 2272 void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; } 2273 uint32_t get_arrayLayer() { return m_struct.arrayLayer; } 2274 void set_arrayLayer(uint32_t inValue) { m_struct.arrayLayer = inValue; } 2275 2276 2277 private: 2278 VkImageSubresource m_struct; 2279 const VkImageSubresource* m_origStructAddr; 2280 uint32_t m_indent; 2281 const char m_dummy_prefix; 2282 void display_struct_members(); 2283 2284 }; 2285 2286 2287 //class declaration 2288 class vkimagesubresourcelayers_struct_wrapper 2289 { 2290 public: 2291 vkimagesubresourcelayers_struct_wrapper(); 2292 vkimagesubresourcelayers_struct_wrapper(VkImageSubresourceLayers* pInStruct); 2293 vkimagesubresourcelayers_struct_wrapper(const VkImageSubresourceLayers* pInStruct); 2294 2295 virtual ~vkimagesubresourcelayers_struct_wrapper(); 2296 2297 void display_txt(); 2298 void display_single_txt(); 2299 void display_full_txt(); 2300 2301 void set_indent(uint32_t indent) { m_indent = indent; } 2302 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 2303 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 2304 uint32_t get_mipLevel() { return m_struct.mipLevel; } 2305 void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; } 2306 uint32_t get_baseArrayLayer() { return m_struct.baseArrayLayer; } 2307 void set_baseArrayLayer(uint32_t inValue) { m_struct.baseArrayLayer = inValue; } 2308 uint32_t get_layerCount() { return m_struct.layerCount; } 2309 void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; } 2310 2311 2312 private: 2313 VkImageSubresourceLayers m_struct; 2314 const VkImageSubresourceLayers* m_origStructAddr; 2315 uint32_t m_indent; 2316 const char m_dummy_prefix; 2317 void display_struct_members(); 2318 2319 }; 2320 2321 2322 //class declaration 2323 class vkimagesubresourcerange_struct_wrapper 2324 { 2325 public: 2326 vkimagesubresourcerange_struct_wrapper(); 2327 vkimagesubresourcerange_struct_wrapper(VkImageSubresourceRange* pInStruct); 2328 vkimagesubresourcerange_struct_wrapper(const VkImageSubresourceRange* pInStruct); 2329 2330 virtual ~vkimagesubresourcerange_struct_wrapper(); 2331 2332 void display_txt(); 2333 void display_single_txt(); 2334 void display_full_txt(); 2335 2336 void set_indent(uint32_t indent) { m_indent = indent; } 2337 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 2338 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 2339 uint32_t get_baseMipLevel() { return m_struct.baseMipLevel; } 2340 void set_baseMipLevel(uint32_t inValue) { m_struct.baseMipLevel = inValue; } 2341 uint32_t get_levelCount() { return m_struct.levelCount; } 2342 void set_levelCount(uint32_t inValue) { m_struct.levelCount = inValue; } 2343 uint32_t get_baseArrayLayer() { return m_struct.baseArrayLayer; } 2344 void set_baseArrayLayer(uint32_t inValue) { m_struct.baseArrayLayer = inValue; } 2345 uint32_t get_layerCount() { return m_struct.layerCount; } 2346 void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; } 2347 2348 2349 private: 2350 VkImageSubresourceRange m_struct; 2351 const VkImageSubresourceRange* m_origStructAddr; 2352 uint32_t m_indent; 2353 const char m_dummy_prefix; 2354 void display_struct_members(); 2355 2356 }; 2357 2358 2359 //class declaration 2360 class vkimageviewcreateinfo_struct_wrapper 2361 { 2362 public: 2363 vkimageviewcreateinfo_struct_wrapper(); 2364 vkimageviewcreateinfo_struct_wrapper(VkImageViewCreateInfo* pInStruct); 2365 vkimageviewcreateinfo_struct_wrapper(const VkImageViewCreateInfo* pInStruct); 2366 2367 virtual ~vkimageviewcreateinfo_struct_wrapper(); 2368 2369 void display_txt(); 2370 void display_single_txt(); 2371 void display_full_txt(); 2372 2373 void set_indent(uint32_t indent) { m_indent = indent; } 2374 VkStructureType get_sType() { return m_struct.sType; } 2375 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2376 const void* get_pNext() { return m_struct.pNext; } 2377 VkImageViewCreateFlags get_flags() { return m_struct.flags; } 2378 void set_flags(VkImageViewCreateFlags inValue) { m_struct.flags = inValue; } 2379 VkImage get_image() { return m_struct.image; } 2380 void set_image(VkImage inValue) { m_struct.image = inValue; } 2381 VkImageViewType get_viewType() { return m_struct.viewType; } 2382 void set_viewType(VkImageViewType inValue) { m_struct.viewType = inValue; } 2383 VkFormat get_format() { return m_struct.format; } 2384 void set_format(VkFormat inValue) { m_struct.format = inValue; } 2385 VkComponentMapping get_components() { return m_struct.components; } 2386 void set_components(VkComponentMapping inValue) { m_struct.components = inValue; } 2387 VkImageSubresourceRange get_subresourceRange() { return m_struct.subresourceRange; } 2388 void set_subresourceRange(VkImageSubresourceRange inValue) { m_struct.subresourceRange = inValue; } 2389 2390 2391 private: 2392 VkImageViewCreateInfo m_struct; 2393 const VkImageViewCreateInfo* m_origStructAddr; 2394 uint32_t m_indent; 2395 const char m_dummy_prefix; 2396 void display_struct_members(); 2397 2398 }; 2399 2400 2401 //class declaration 2402 class vkinstancecreateinfo_struct_wrapper 2403 { 2404 public: 2405 vkinstancecreateinfo_struct_wrapper(); 2406 vkinstancecreateinfo_struct_wrapper(VkInstanceCreateInfo* pInStruct); 2407 vkinstancecreateinfo_struct_wrapper(const VkInstanceCreateInfo* pInStruct); 2408 2409 virtual ~vkinstancecreateinfo_struct_wrapper(); 2410 2411 void display_txt(); 2412 void display_single_txt(); 2413 void display_full_txt(); 2414 2415 void set_indent(uint32_t indent) { m_indent = indent; } 2416 VkStructureType get_sType() { return m_struct.sType; } 2417 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2418 const void* get_pNext() { return m_struct.pNext; } 2419 VkInstanceCreateFlags get_flags() { return m_struct.flags; } 2420 void set_flags(VkInstanceCreateFlags inValue) { m_struct.flags = inValue; } 2421 const VkApplicationInfo* get_pApplicationInfo() { return m_struct.pApplicationInfo; } 2422 uint32_t get_enabledLayerCount() { return m_struct.enabledLayerCount; } 2423 void set_enabledLayerCount(uint32_t inValue) { m_struct.enabledLayerCount = inValue; } 2424 uint32_t get_enabledExtensionCount() { return m_struct.enabledExtensionCount; } 2425 void set_enabledExtensionCount(uint32_t inValue) { m_struct.enabledExtensionCount = inValue; } 2426 2427 2428 private: 2429 VkInstanceCreateInfo m_struct; 2430 const VkInstanceCreateInfo* m_origStructAddr; 2431 uint32_t m_indent; 2432 const char m_dummy_prefix; 2433 void display_struct_members(); 2434 2435 }; 2436 2437 2438 //class declaration 2439 class vklayerproperties_struct_wrapper 2440 { 2441 public: 2442 vklayerproperties_struct_wrapper(); 2443 vklayerproperties_struct_wrapper(VkLayerProperties* pInStruct); 2444 vklayerproperties_struct_wrapper(const VkLayerProperties* pInStruct); 2445 2446 virtual ~vklayerproperties_struct_wrapper(); 2447 2448 void display_txt(); 2449 void display_single_txt(); 2450 void display_full_txt(); 2451 2452 void set_indent(uint32_t indent) { m_indent = indent; } 2453 uint32_t get_specVersion() { return m_struct.specVersion; } 2454 void set_specVersion(uint32_t inValue) { m_struct.specVersion = inValue; } 2455 uint32_t get_implementationVersion() { return m_struct.implementationVersion; } 2456 void set_implementationVersion(uint32_t inValue) { m_struct.implementationVersion = inValue; } 2457 2458 2459 private: 2460 VkLayerProperties m_struct; 2461 const VkLayerProperties* m_origStructAddr; 2462 uint32_t m_indent; 2463 const char m_dummy_prefix; 2464 void display_struct_members(); 2465 2466 }; 2467 2468 2469 //class declaration 2470 class vkmappedmemoryrange_struct_wrapper 2471 { 2472 public: 2473 vkmappedmemoryrange_struct_wrapper(); 2474 vkmappedmemoryrange_struct_wrapper(VkMappedMemoryRange* pInStruct); 2475 vkmappedmemoryrange_struct_wrapper(const VkMappedMemoryRange* pInStruct); 2476 2477 virtual ~vkmappedmemoryrange_struct_wrapper(); 2478 2479 void display_txt(); 2480 void display_single_txt(); 2481 void display_full_txt(); 2482 2483 void set_indent(uint32_t indent) { m_indent = indent; } 2484 VkStructureType get_sType() { return m_struct.sType; } 2485 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2486 const void* get_pNext() { return m_struct.pNext; } 2487 VkDeviceMemory get_memory() { return m_struct.memory; } 2488 void set_memory(VkDeviceMemory inValue) { m_struct.memory = inValue; } 2489 VkDeviceSize get_offset() { return m_struct.offset; } 2490 void set_offset(VkDeviceSize inValue) { m_struct.offset = inValue; } 2491 VkDeviceSize get_size() { return m_struct.size; } 2492 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 2493 2494 2495 private: 2496 VkMappedMemoryRange m_struct; 2497 const VkMappedMemoryRange* m_origStructAddr; 2498 uint32_t m_indent; 2499 const char m_dummy_prefix; 2500 void display_struct_members(); 2501 2502 }; 2503 2504 2505 //class declaration 2506 class vkmemoryallocateinfo_struct_wrapper 2507 { 2508 public: 2509 vkmemoryallocateinfo_struct_wrapper(); 2510 vkmemoryallocateinfo_struct_wrapper(VkMemoryAllocateInfo* pInStruct); 2511 vkmemoryallocateinfo_struct_wrapper(const VkMemoryAllocateInfo* pInStruct); 2512 2513 virtual ~vkmemoryallocateinfo_struct_wrapper(); 2514 2515 void display_txt(); 2516 void display_single_txt(); 2517 void display_full_txt(); 2518 2519 void set_indent(uint32_t indent) { m_indent = indent; } 2520 VkStructureType get_sType() { return m_struct.sType; } 2521 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2522 const void* get_pNext() { return m_struct.pNext; } 2523 VkDeviceSize get_allocationSize() { return m_struct.allocationSize; } 2524 void set_allocationSize(VkDeviceSize inValue) { m_struct.allocationSize = inValue; } 2525 uint32_t get_memoryTypeIndex() { return m_struct.memoryTypeIndex; } 2526 void set_memoryTypeIndex(uint32_t inValue) { m_struct.memoryTypeIndex = inValue; } 2527 2528 2529 private: 2530 VkMemoryAllocateInfo m_struct; 2531 const VkMemoryAllocateInfo* m_origStructAddr; 2532 uint32_t m_indent; 2533 const char m_dummy_prefix; 2534 void display_struct_members(); 2535 2536 }; 2537 2538 2539 //class declaration 2540 class vkmemorybarrier_struct_wrapper 2541 { 2542 public: 2543 vkmemorybarrier_struct_wrapper(); 2544 vkmemorybarrier_struct_wrapper(VkMemoryBarrier* pInStruct); 2545 vkmemorybarrier_struct_wrapper(const VkMemoryBarrier* pInStruct); 2546 2547 virtual ~vkmemorybarrier_struct_wrapper(); 2548 2549 void display_txt(); 2550 void display_single_txt(); 2551 void display_full_txt(); 2552 2553 void set_indent(uint32_t indent) { m_indent = indent; } 2554 VkStructureType get_sType() { return m_struct.sType; } 2555 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2556 const void* get_pNext() { return m_struct.pNext; } 2557 VkAccessFlags get_srcAccessMask() { return m_struct.srcAccessMask; } 2558 void set_srcAccessMask(VkAccessFlags inValue) { m_struct.srcAccessMask = inValue; } 2559 VkAccessFlags get_dstAccessMask() { return m_struct.dstAccessMask; } 2560 void set_dstAccessMask(VkAccessFlags inValue) { m_struct.dstAccessMask = inValue; } 2561 2562 2563 private: 2564 VkMemoryBarrier m_struct; 2565 const VkMemoryBarrier* m_origStructAddr; 2566 uint32_t m_indent; 2567 const char m_dummy_prefix; 2568 void display_struct_members(); 2569 2570 }; 2571 2572 2573 //class declaration 2574 class vkmemoryheap_struct_wrapper 2575 { 2576 public: 2577 vkmemoryheap_struct_wrapper(); 2578 vkmemoryheap_struct_wrapper(VkMemoryHeap* pInStruct); 2579 vkmemoryheap_struct_wrapper(const VkMemoryHeap* pInStruct); 2580 2581 virtual ~vkmemoryheap_struct_wrapper(); 2582 2583 void display_txt(); 2584 void display_single_txt(); 2585 void display_full_txt(); 2586 2587 void set_indent(uint32_t indent) { m_indent = indent; } 2588 VkDeviceSize get_size() { return m_struct.size; } 2589 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 2590 VkMemoryHeapFlags get_flags() { return m_struct.flags; } 2591 void set_flags(VkMemoryHeapFlags inValue) { m_struct.flags = inValue; } 2592 2593 2594 private: 2595 VkMemoryHeap m_struct; 2596 const VkMemoryHeap* m_origStructAddr; 2597 uint32_t m_indent; 2598 const char m_dummy_prefix; 2599 void display_struct_members(); 2600 2601 }; 2602 2603 2604 //class declaration 2605 class vkmemoryrequirements_struct_wrapper 2606 { 2607 public: 2608 vkmemoryrequirements_struct_wrapper(); 2609 vkmemoryrequirements_struct_wrapper(VkMemoryRequirements* pInStruct); 2610 vkmemoryrequirements_struct_wrapper(const VkMemoryRequirements* pInStruct); 2611 2612 virtual ~vkmemoryrequirements_struct_wrapper(); 2613 2614 void display_txt(); 2615 void display_single_txt(); 2616 void display_full_txt(); 2617 2618 void set_indent(uint32_t indent) { m_indent = indent; } 2619 VkDeviceSize get_size() { return m_struct.size; } 2620 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 2621 VkDeviceSize get_alignment() { return m_struct.alignment; } 2622 void set_alignment(VkDeviceSize inValue) { m_struct.alignment = inValue; } 2623 uint32_t get_memoryTypeBits() { return m_struct.memoryTypeBits; } 2624 void set_memoryTypeBits(uint32_t inValue) { m_struct.memoryTypeBits = inValue; } 2625 2626 2627 private: 2628 VkMemoryRequirements m_struct; 2629 const VkMemoryRequirements* m_origStructAddr; 2630 uint32_t m_indent; 2631 const char m_dummy_prefix; 2632 void display_struct_members(); 2633 2634 }; 2635 2636 2637 //class declaration 2638 class vkmemorytype_struct_wrapper 2639 { 2640 public: 2641 vkmemorytype_struct_wrapper(); 2642 vkmemorytype_struct_wrapper(VkMemoryType* pInStruct); 2643 vkmemorytype_struct_wrapper(const VkMemoryType* pInStruct); 2644 2645 virtual ~vkmemorytype_struct_wrapper(); 2646 2647 void display_txt(); 2648 void display_single_txt(); 2649 void display_full_txt(); 2650 2651 void set_indent(uint32_t indent) { m_indent = indent; } 2652 VkMemoryPropertyFlags get_propertyFlags() { return m_struct.propertyFlags; } 2653 void set_propertyFlags(VkMemoryPropertyFlags inValue) { m_struct.propertyFlags = inValue; } 2654 uint32_t get_heapIndex() { return m_struct.heapIndex; } 2655 void set_heapIndex(uint32_t inValue) { m_struct.heapIndex = inValue; } 2656 2657 2658 private: 2659 VkMemoryType m_struct; 2660 const VkMemoryType* m_origStructAddr; 2661 uint32_t m_indent; 2662 const char m_dummy_prefix; 2663 void display_struct_members(); 2664 2665 }; 2666 2667 2668 //class declaration 2669 class vkmirsurfacecreateinfokhr_struct_wrapper 2670 { 2671 public: 2672 vkmirsurfacecreateinfokhr_struct_wrapper(); 2673 vkmirsurfacecreateinfokhr_struct_wrapper(VkMirSurfaceCreateInfoKHR* pInStruct); 2674 vkmirsurfacecreateinfokhr_struct_wrapper(const VkMirSurfaceCreateInfoKHR* pInStruct); 2675 2676 virtual ~vkmirsurfacecreateinfokhr_struct_wrapper(); 2677 2678 void display_txt(); 2679 void display_single_txt(); 2680 void display_full_txt(); 2681 2682 void set_indent(uint32_t indent) { m_indent = indent; } 2683 VkStructureType get_sType() { return m_struct.sType; } 2684 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2685 const void* get_pNext() { return m_struct.pNext; } 2686 VkMirSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 2687 void set_flags(VkMirSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 2688 MirConnection* get_connection() { return m_struct.connection; } 2689 void set_connection(MirConnection* inValue) { m_struct.connection = inValue; } 2690 MirSurface* get_mirSurface() { return m_struct.mirSurface; } 2691 void set_mirSurface(MirSurface* inValue) { m_struct.mirSurface = inValue; } 2692 2693 2694 private: 2695 VkMirSurfaceCreateInfoKHR m_struct; 2696 const VkMirSurfaceCreateInfoKHR* m_origStructAddr; 2697 uint32_t m_indent; 2698 const char m_dummy_prefix; 2699 void display_struct_members(); 2700 2701 }; 2702 2703 2704 //class declaration 2705 class vkoffset2d_struct_wrapper 2706 { 2707 public: 2708 vkoffset2d_struct_wrapper(); 2709 vkoffset2d_struct_wrapper(VkOffset2D* pInStruct); 2710 vkoffset2d_struct_wrapper(const VkOffset2D* pInStruct); 2711 2712 virtual ~vkoffset2d_struct_wrapper(); 2713 2714 void display_txt(); 2715 void display_single_txt(); 2716 void display_full_txt(); 2717 2718 void set_indent(uint32_t indent) { m_indent = indent; } 2719 int32_t get_x() { return m_struct.x; } 2720 void set_x(int32_t inValue) { m_struct.x = inValue; } 2721 int32_t get_y() { return m_struct.y; } 2722 void set_y(int32_t inValue) { m_struct.y = inValue; } 2723 2724 2725 private: 2726 VkOffset2D m_struct; 2727 const VkOffset2D* m_origStructAddr; 2728 uint32_t m_indent; 2729 const char m_dummy_prefix; 2730 void display_struct_members(); 2731 2732 }; 2733 2734 2735 //class declaration 2736 class vkoffset3d_struct_wrapper 2737 { 2738 public: 2739 vkoffset3d_struct_wrapper(); 2740 vkoffset3d_struct_wrapper(VkOffset3D* pInStruct); 2741 vkoffset3d_struct_wrapper(const VkOffset3D* pInStruct); 2742 2743 virtual ~vkoffset3d_struct_wrapper(); 2744 2745 void display_txt(); 2746 void display_single_txt(); 2747 void display_full_txt(); 2748 2749 void set_indent(uint32_t indent) { m_indent = indent; } 2750 int32_t get_x() { return m_struct.x; } 2751 void set_x(int32_t inValue) { m_struct.x = inValue; } 2752 int32_t get_y() { return m_struct.y; } 2753 void set_y(int32_t inValue) { m_struct.y = inValue; } 2754 int32_t get_z() { return m_struct.z; } 2755 void set_z(int32_t inValue) { m_struct.z = inValue; } 2756 2757 2758 private: 2759 VkOffset3D m_struct; 2760 const VkOffset3D* m_origStructAddr; 2761 uint32_t m_indent; 2762 const char m_dummy_prefix; 2763 void display_struct_members(); 2764 2765 }; 2766 2767 2768 //class declaration 2769 class vkphysicaldevicefeatures_struct_wrapper 2770 { 2771 public: 2772 vkphysicaldevicefeatures_struct_wrapper(); 2773 vkphysicaldevicefeatures_struct_wrapper(VkPhysicalDeviceFeatures* pInStruct); 2774 vkphysicaldevicefeatures_struct_wrapper(const VkPhysicalDeviceFeatures* pInStruct); 2775 2776 virtual ~vkphysicaldevicefeatures_struct_wrapper(); 2777 2778 void display_txt(); 2779 void display_single_txt(); 2780 void display_full_txt(); 2781 2782 void set_indent(uint32_t indent) { m_indent = indent; } 2783 VkBool32 get_robustBufferAccess() { return m_struct.robustBufferAccess; } 2784 void set_robustBufferAccess(VkBool32 inValue) { m_struct.robustBufferAccess = inValue; } 2785 VkBool32 get_fullDrawIndexUint32() { return m_struct.fullDrawIndexUint32; } 2786 void set_fullDrawIndexUint32(VkBool32 inValue) { m_struct.fullDrawIndexUint32 = inValue; } 2787 VkBool32 get_imageCubeArray() { return m_struct.imageCubeArray; } 2788 void set_imageCubeArray(VkBool32 inValue) { m_struct.imageCubeArray = inValue; } 2789 VkBool32 get_independentBlend() { return m_struct.independentBlend; } 2790 void set_independentBlend(VkBool32 inValue) { m_struct.independentBlend = inValue; } 2791 VkBool32 get_geometryShader() { return m_struct.geometryShader; } 2792 void set_geometryShader(VkBool32 inValue) { m_struct.geometryShader = inValue; } 2793 VkBool32 get_tessellationShader() { return m_struct.tessellationShader; } 2794 void set_tessellationShader(VkBool32 inValue) { m_struct.tessellationShader = inValue; } 2795 VkBool32 get_sampleRateShading() { return m_struct.sampleRateShading; } 2796 void set_sampleRateShading(VkBool32 inValue) { m_struct.sampleRateShading = inValue; } 2797 VkBool32 get_dualSrcBlend() { return m_struct.dualSrcBlend; } 2798 void set_dualSrcBlend(VkBool32 inValue) { m_struct.dualSrcBlend = inValue; } 2799 VkBool32 get_logicOp() { return m_struct.logicOp; } 2800 void set_logicOp(VkBool32 inValue) { m_struct.logicOp = inValue; } 2801 VkBool32 get_multiDrawIndirect() { return m_struct.multiDrawIndirect; } 2802 void set_multiDrawIndirect(VkBool32 inValue) { m_struct.multiDrawIndirect = inValue; } 2803 VkBool32 get_drawIndirectFirstInstance() { return m_struct.drawIndirectFirstInstance; } 2804 void set_drawIndirectFirstInstance(VkBool32 inValue) { m_struct.drawIndirectFirstInstance = inValue; } 2805 VkBool32 get_depthClamp() { return m_struct.depthClamp; } 2806 void set_depthClamp(VkBool32 inValue) { m_struct.depthClamp = inValue; } 2807 VkBool32 get_depthBiasClamp() { return m_struct.depthBiasClamp; } 2808 void set_depthBiasClamp(VkBool32 inValue) { m_struct.depthBiasClamp = inValue; } 2809 VkBool32 get_fillModeNonSolid() { return m_struct.fillModeNonSolid; } 2810 void set_fillModeNonSolid(VkBool32 inValue) { m_struct.fillModeNonSolid = inValue; } 2811 VkBool32 get_depthBounds() { return m_struct.depthBounds; } 2812 void set_depthBounds(VkBool32 inValue) { m_struct.depthBounds = inValue; } 2813 VkBool32 get_wideLines() { return m_struct.wideLines; } 2814 void set_wideLines(VkBool32 inValue) { m_struct.wideLines = inValue; } 2815 VkBool32 get_largePoints() { return m_struct.largePoints; } 2816 void set_largePoints(VkBool32 inValue) { m_struct.largePoints = inValue; } 2817 VkBool32 get_alphaToOne() { return m_struct.alphaToOne; } 2818 void set_alphaToOne(VkBool32 inValue) { m_struct.alphaToOne = inValue; } 2819 VkBool32 get_multiViewport() { return m_struct.multiViewport; } 2820 void set_multiViewport(VkBool32 inValue) { m_struct.multiViewport = inValue; } 2821 VkBool32 get_samplerAnisotropy() { return m_struct.samplerAnisotropy; } 2822 void set_samplerAnisotropy(VkBool32 inValue) { m_struct.samplerAnisotropy = inValue; } 2823 VkBool32 get_textureCompressionETC2() { return m_struct.textureCompressionETC2; } 2824 void set_textureCompressionETC2(VkBool32 inValue) { m_struct.textureCompressionETC2 = inValue; } 2825 VkBool32 get_textureCompressionASTC_LDR() { return m_struct.textureCompressionASTC_LDR; } 2826 void set_textureCompressionASTC_LDR(VkBool32 inValue) { m_struct.textureCompressionASTC_LDR = inValue; } 2827 VkBool32 get_textureCompressionBC() { return m_struct.textureCompressionBC; } 2828 void set_textureCompressionBC(VkBool32 inValue) { m_struct.textureCompressionBC = inValue; } 2829 VkBool32 get_occlusionQueryPrecise() { return m_struct.occlusionQueryPrecise; } 2830 void set_occlusionQueryPrecise(VkBool32 inValue) { m_struct.occlusionQueryPrecise = inValue; } 2831 VkBool32 get_pipelineStatisticsQuery() { return m_struct.pipelineStatisticsQuery; } 2832 void set_pipelineStatisticsQuery(VkBool32 inValue) { m_struct.pipelineStatisticsQuery = inValue; } 2833 VkBool32 get_vertexPipelineStoresAndAtomics() { return m_struct.vertexPipelineStoresAndAtomics; } 2834 void set_vertexPipelineStoresAndAtomics(VkBool32 inValue) { m_struct.vertexPipelineStoresAndAtomics = inValue; } 2835 VkBool32 get_fragmentStoresAndAtomics() { return m_struct.fragmentStoresAndAtomics; } 2836 void set_fragmentStoresAndAtomics(VkBool32 inValue) { m_struct.fragmentStoresAndAtomics = inValue; } 2837 VkBool32 get_shaderTessellationAndGeometryPointSize() { return m_struct.shaderTessellationAndGeometryPointSize; } 2838 void set_shaderTessellationAndGeometryPointSize(VkBool32 inValue) { m_struct.shaderTessellationAndGeometryPointSize = inValue; } 2839 VkBool32 get_shaderImageGatherExtended() { return m_struct.shaderImageGatherExtended; } 2840 void set_shaderImageGatherExtended(VkBool32 inValue) { m_struct.shaderImageGatherExtended = inValue; } 2841 VkBool32 get_shaderStorageImageExtendedFormats() { return m_struct.shaderStorageImageExtendedFormats; } 2842 void set_shaderStorageImageExtendedFormats(VkBool32 inValue) { m_struct.shaderStorageImageExtendedFormats = inValue; } 2843 VkBool32 get_shaderStorageImageMultisample() { return m_struct.shaderStorageImageMultisample; } 2844 void set_shaderStorageImageMultisample(VkBool32 inValue) { m_struct.shaderStorageImageMultisample = inValue; } 2845 VkBool32 get_shaderStorageImageReadWithoutFormat() { return m_struct.shaderStorageImageReadWithoutFormat; } 2846 void set_shaderStorageImageReadWithoutFormat(VkBool32 inValue) { m_struct.shaderStorageImageReadWithoutFormat = inValue; } 2847 VkBool32 get_shaderStorageImageWriteWithoutFormat() { return m_struct.shaderStorageImageWriteWithoutFormat; } 2848 void set_shaderStorageImageWriteWithoutFormat(VkBool32 inValue) { m_struct.shaderStorageImageWriteWithoutFormat = inValue; } 2849 VkBool32 get_shaderUniformBufferArrayDynamicIndexing() { return m_struct.shaderUniformBufferArrayDynamicIndexing; } 2850 void set_shaderUniformBufferArrayDynamicIndexing(VkBool32 inValue) { m_struct.shaderUniformBufferArrayDynamicIndexing = inValue; } 2851 VkBool32 get_shaderSampledImageArrayDynamicIndexing() { return m_struct.shaderSampledImageArrayDynamicIndexing; } 2852 void set_shaderSampledImageArrayDynamicIndexing(VkBool32 inValue) { m_struct.shaderSampledImageArrayDynamicIndexing = inValue; } 2853 VkBool32 get_shaderStorageBufferArrayDynamicIndexing() { return m_struct.shaderStorageBufferArrayDynamicIndexing; } 2854 void set_shaderStorageBufferArrayDynamicIndexing(VkBool32 inValue) { m_struct.shaderStorageBufferArrayDynamicIndexing = inValue; } 2855 VkBool32 get_shaderStorageImageArrayDynamicIndexing() { return m_struct.shaderStorageImageArrayDynamicIndexing; } 2856 void set_shaderStorageImageArrayDynamicIndexing(VkBool32 inValue) { m_struct.shaderStorageImageArrayDynamicIndexing = inValue; } 2857 VkBool32 get_shaderClipDistance() { return m_struct.shaderClipDistance; } 2858 void set_shaderClipDistance(VkBool32 inValue) { m_struct.shaderClipDistance = inValue; } 2859 VkBool32 get_shaderCullDistance() { return m_struct.shaderCullDistance; } 2860 void set_shaderCullDistance(VkBool32 inValue) { m_struct.shaderCullDistance = inValue; } 2861 VkBool32 get_shaderFloat64() { return m_struct.shaderFloat64; } 2862 void set_shaderFloat64(VkBool32 inValue) { m_struct.shaderFloat64 = inValue; } 2863 VkBool32 get_shaderInt64() { return m_struct.shaderInt64; } 2864 void set_shaderInt64(VkBool32 inValue) { m_struct.shaderInt64 = inValue; } 2865 VkBool32 get_shaderInt16() { return m_struct.shaderInt16; } 2866 void set_shaderInt16(VkBool32 inValue) { m_struct.shaderInt16 = inValue; } 2867 VkBool32 get_shaderResourceResidency() { return m_struct.shaderResourceResidency; } 2868 void set_shaderResourceResidency(VkBool32 inValue) { m_struct.shaderResourceResidency = inValue; } 2869 VkBool32 get_shaderResourceMinLod() { return m_struct.shaderResourceMinLod; } 2870 void set_shaderResourceMinLod(VkBool32 inValue) { m_struct.shaderResourceMinLod = inValue; } 2871 VkBool32 get_sparseBinding() { return m_struct.sparseBinding; } 2872 void set_sparseBinding(VkBool32 inValue) { m_struct.sparseBinding = inValue; } 2873 VkBool32 get_sparseResidencyBuffer() { return m_struct.sparseResidencyBuffer; } 2874 void set_sparseResidencyBuffer(VkBool32 inValue) { m_struct.sparseResidencyBuffer = inValue; } 2875 VkBool32 get_sparseResidencyImage2D() { return m_struct.sparseResidencyImage2D; } 2876 void set_sparseResidencyImage2D(VkBool32 inValue) { m_struct.sparseResidencyImage2D = inValue; } 2877 VkBool32 get_sparseResidencyImage3D() { return m_struct.sparseResidencyImage3D; } 2878 void set_sparseResidencyImage3D(VkBool32 inValue) { m_struct.sparseResidencyImage3D = inValue; } 2879 VkBool32 get_sparseResidency2Samples() { return m_struct.sparseResidency2Samples; } 2880 void set_sparseResidency2Samples(VkBool32 inValue) { m_struct.sparseResidency2Samples = inValue; } 2881 VkBool32 get_sparseResidency4Samples() { return m_struct.sparseResidency4Samples; } 2882 void set_sparseResidency4Samples(VkBool32 inValue) { m_struct.sparseResidency4Samples = inValue; } 2883 VkBool32 get_sparseResidency8Samples() { return m_struct.sparseResidency8Samples; } 2884 void set_sparseResidency8Samples(VkBool32 inValue) { m_struct.sparseResidency8Samples = inValue; } 2885 VkBool32 get_sparseResidency16Samples() { return m_struct.sparseResidency16Samples; } 2886 void set_sparseResidency16Samples(VkBool32 inValue) { m_struct.sparseResidency16Samples = inValue; } 2887 VkBool32 get_sparseResidencyAliased() { return m_struct.sparseResidencyAliased; } 2888 void set_sparseResidencyAliased(VkBool32 inValue) { m_struct.sparseResidencyAliased = inValue; } 2889 VkBool32 get_variableMultisampleRate() { return m_struct.variableMultisampleRate; } 2890 void set_variableMultisampleRate(VkBool32 inValue) { m_struct.variableMultisampleRate = inValue; } 2891 VkBool32 get_inheritedQueries() { return m_struct.inheritedQueries; } 2892 void set_inheritedQueries(VkBool32 inValue) { m_struct.inheritedQueries = inValue; } 2893 2894 2895 private: 2896 VkPhysicalDeviceFeatures m_struct; 2897 const VkPhysicalDeviceFeatures* m_origStructAddr; 2898 uint32_t m_indent; 2899 const char m_dummy_prefix; 2900 void display_struct_members(); 2901 2902 }; 2903 2904 2905 //class declaration 2906 class vkphysicaldevicelimits_struct_wrapper 2907 { 2908 public: 2909 vkphysicaldevicelimits_struct_wrapper(); 2910 vkphysicaldevicelimits_struct_wrapper(VkPhysicalDeviceLimits* pInStruct); 2911 vkphysicaldevicelimits_struct_wrapper(const VkPhysicalDeviceLimits* pInStruct); 2912 2913 virtual ~vkphysicaldevicelimits_struct_wrapper(); 2914 2915 void display_txt(); 2916 void display_single_txt(); 2917 void display_full_txt(); 2918 2919 void set_indent(uint32_t indent) { m_indent = indent; } 2920 uint32_t get_maxImageDimension1D() { return m_struct.maxImageDimension1D; } 2921 void set_maxImageDimension1D(uint32_t inValue) { m_struct.maxImageDimension1D = inValue; } 2922 uint32_t get_maxImageDimension2D() { return m_struct.maxImageDimension2D; } 2923 void set_maxImageDimension2D(uint32_t inValue) { m_struct.maxImageDimension2D = inValue; } 2924 uint32_t get_maxImageDimension3D() { return m_struct.maxImageDimension3D; } 2925 void set_maxImageDimension3D(uint32_t inValue) { m_struct.maxImageDimension3D = inValue; } 2926 uint32_t get_maxImageDimensionCube() { return m_struct.maxImageDimensionCube; } 2927 void set_maxImageDimensionCube(uint32_t inValue) { m_struct.maxImageDimensionCube = inValue; } 2928 uint32_t get_maxImageArrayLayers() { return m_struct.maxImageArrayLayers; } 2929 void set_maxImageArrayLayers(uint32_t inValue) { m_struct.maxImageArrayLayers = inValue; } 2930 uint32_t get_maxTexelBufferElements() { return m_struct.maxTexelBufferElements; } 2931 void set_maxTexelBufferElements(uint32_t inValue) { m_struct.maxTexelBufferElements = inValue; } 2932 uint32_t get_maxUniformBufferRange() { return m_struct.maxUniformBufferRange; } 2933 void set_maxUniformBufferRange(uint32_t inValue) { m_struct.maxUniformBufferRange = inValue; } 2934 uint32_t get_maxStorageBufferRange() { return m_struct.maxStorageBufferRange; } 2935 void set_maxStorageBufferRange(uint32_t inValue) { m_struct.maxStorageBufferRange = inValue; } 2936 uint32_t get_maxPushConstantsSize() { return m_struct.maxPushConstantsSize; } 2937 void set_maxPushConstantsSize(uint32_t inValue) { m_struct.maxPushConstantsSize = inValue; } 2938 uint32_t get_maxMemoryAllocationCount() { return m_struct.maxMemoryAllocationCount; } 2939 void set_maxMemoryAllocationCount(uint32_t inValue) { m_struct.maxMemoryAllocationCount = inValue; } 2940 uint32_t get_maxSamplerAllocationCount() { return m_struct.maxSamplerAllocationCount; } 2941 void set_maxSamplerAllocationCount(uint32_t inValue) { m_struct.maxSamplerAllocationCount = inValue; } 2942 VkDeviceSize get_bufferImageGranularity() { return m_struct.bufferImageGranularity; } 2943 void set_bufferImageGranularity(VkDeviceSize inValue) { m_struct.bufferImageGranularity = inValue; } 2944 VkDeviceSize get_sparseAddressSpaceSize() { return m_struct.sparseAddressSpaceSize; } 2945 void set_sparseAddressSpaceSize(VkDeviceSize inValue) { m_struct.sparseAddressSpaceSize = inValue; } 2946 uint32_t get_maxBoundDescriptorSets() { return m_struct.maxBoundDescriptorSets; } 2947 void set_maxBoundDescriptorSets(uint32_t inValue) { m_struct.maxBoundDescriptorSets = inValue; } 2948 uint32_t get_maxPerStageDescriptorSamplers() { return m_struct.maxPerStageDescriptorSamplers; } 2949 void set_maxPerStageDescriptorSamplers(uint32_t inValue) { m_struct.maxPerStageDescriptorSamplers = inValue; } 2950 uint32_t get_maxPerStageDescriptorUniformBuffers() { return m_struct.maxPerStageDescriptorUniformBuffers; } 2951 void set_maxPerStageDescriptorUniformBuffers(uint32_t inValue) { m_struct.maxPerStageDescriptorUniformBuffers = inValue; } 2952 uint32_t get_maxPerStageDescriptorStorageBuffers() { return m_struct.maxPerStageDescriptorStorageBuffers; } 2953 void set_maxPerStageDescriptorStorageBuffers(uint32_t inValue) { m_struct.maxPerStageDescriptorStorageBuffers = inValue; } 2954 uint32_t get_maxPerStageDescriptorSampledImages() { return m_struct.maxPerStageDescriptorSampledImages; } 2955 void set_maxPerStageDescriptorSampledImages(uint32_t inValue) { m_struct.maxPerStageDescriptorSampledImages = inValue; } 2956 uint32_t get_maxPerStageDescriptorStorageImages() { return m_struct.maxPerStageDescriptorStorageImages; } 2957 void set_maxPerStageDescriptorStorageImages(uint32_t inValue) { m_struct.maxPerStageDescriptorStorageImages = inValue; } 2958 uint32_t get_maxPerStageDescriptorInputAttachments() { return m_struct.maxPerStageDescriptorInputAttachments; } 2959 void set_maxPerStageDescriptorInputAttachments(uint32_t inValue) { m_struct.maxPerStageDescriptorInputAttachments = inValue; } 2960 uint32_t get_maxPerStageResources() { return m_struct.maxPerStageResources; } 2961 void set_maxPerStageResources(uint32_t inValue) { m_struct.maxPerStageResources = inValue; } 2962 uint32_t get_maxDescriptorSetSamplers() { return m_struct.maxDescriptorSetSamplers; } 2963 void set_maxDescriptorSetSamplers(uint32_t inValue) { m_struct.maxDescriptorSetSamplers = inValue; } 2964 uint32_t get_maxDescriptorSetUniformBuffers() { return m_struct.maxDescriptorSetUniformBuffers; } 2965 void set_maxDescriptorSetUniformBuffers(uint32_t inValue) { m_struct.maxDescriptorSetUniformBuffers = inValue; } 2966 uint32_t get_maxDescriptorSetUniformBuffersDynamic() { return m_struct.maxDescriptorSetUniformBuffersDynamic; } 2967 void set_maxDescriptorSetUniformBuffersDynamic(uint32_t inValue) { m_struct.maxDescriptorSetUniformBuffersDynamic = inValue; } 2968 uint32_t get_maxDescriptorSetStorageBuffers() { return m_struct.maxDescriptorSetStorageBuffers; } 2969 void set_maxDescriptorSetStorageBuffers(uint32_t inValue) { m_struct.maxDescriptorSetStorageBuffers = inValue; } 2970 uint32_t get_maxDescriptorSetStorageBuffersDynamic() { return m_struct.maxDescriptorSetStorageBuffersDynamic; } 2971 void set_maxDescriptorSetStorageBuffersDynamic(uint32_t inValue) { m_struct.maxDescriptorSetStorageBuffersDynamic = inValue; } 2972 uint32_t get_maxDescriptorSetSampledImages() { return m_struct.maxDescriptorSetSampledImages; } 2973 void set_maxDescriptorSetSampledImages(uint32_t inValue) { m_struct.maxDescriptorSetSampledImages = inValue; } 2974 uint32_t get_maxDescriptorSetStorageImages() { return m_struct.maxDescriptorSetStorageImages; } 2975 void set_maxDescriptorSetStorageImages(uint32_t inValue) { m_struct.maxDescriptorSetStorageImages = inValue; } 2976 uint32_t get_maxDescriptorSetInputAttachments() { return m_struct.maxDescriptorSetInputAttachments; } 2977 void set_maxDescriptorSetInputAttachments(uint32_t inValue) { m_struct.maxDescriptorSetInputAttachments = inValue; } 2978 uint32_t get_maxVertexInputAttributes() { return m_struct.maxVertexInputAttributes; } 2979 void set_maxVertexInputAttributes(uint32_t inValue) { m_struct.maxVertexInputAttributes = inValue; } 2980 uint32_t get_maxVertexInputBindings() { return m_struct.maxVertexInputBindings; } 2981 void set_maxVertexInputBindings(uint32_t inValue) { m_struct.maxVertexInputBindings = inValue; } 2982 uint32_t get_maxVertexInputAttributeOffset() { return m_struct.maxVertexInputAttributeOffset; } 2983 void set_maxVertexInputAttributeOffset(uint32_t inValue) { m_struct.maxVertexInputAttributeOffset = inValue; } 2984 uint32_t get_maxVertexInputBindingStride() { return m_struct.maxVertexInputBindingStride; } 2985 void set_maxVertexInputBindingStride(uint32_t inValue) { m_struct.maxVertexInputBindingStride = inValue; } 2986 uint32_t get_maxVertexOutputComponents() { return m_struct.maxVertexOutputComponents; } 2987 void set_maxVertexOutputComponents(uint32_t inValue) { m_struct.maxVertexOutputComponents = inValue; } 2988 uint32_t get_maxTessellationGenerationLevel() { return m_struct.maxTessellationGenerationLevel; } 2989 void set_maxTessellationGenerationLevel(uint32_t inValue) { m_struct.maxTessellationGenerationLevel = inValue; } 2990 uint32_t get_maxTessellationPatchSize() { return m_struct.maxTessellationPatchSize; } 2991 void set_maxTessellationPatchSize(uint32_t inValue) { m_struct.maxTessellationPatchSize = inValue; } 2992 uint32_t get_maxTessellationControlPerVertexInputComponents() { return m_struct.maxTessellationControlPerVertexInputComponents; } 2993 void set_maxTessellationControlPerVertexInputComponents(uint32_t inValue) { m_struct.maxTessellationControlPerVertexInputComponents = inValue; } 2994 uint32_t get_maxTessellationControlPerVertexOutputComponents() { return m_struct.maxTessellationControlPerVertexOutputComponents; } 2995 void set_maxTessellationControlPerVertexOutputComponents(uint32_t inValue) { m_struct.maxTessellationControlPerVertexOutputComponents = inValue; } 2996 uint32_t get_maxTessellationControlPerPatchOutputComponents() { return m_struct.maxTessellationControlPerPatchOutputComponents; } 2997 void set_maxTessellationControlPerPatchOutputComponents(uint32_t inValue) { m_struct.maxTessellationControlPerPatchOutputComponents = inValue; } 2998 uint32_t get_maxTessellationControlTotalOutputComponents() { return m_struct.maxTessellationControlTotalOutputComponents; } 2999 void set_maxTessellationControlTotalOutputComponents(uint32_t inValue) { m_struct.maxTessellationControlTotalOutputComponents = inValue; } 3000 uint32_t get_maxTessellationEvaluationInputComponents() { return m_struct.maxTessellationEvaluationInputComponents; } 3001 void set_maxTessellationEvaluationInputComponents(uint32_t inValue) { m_struct.maxTessellationEvaluationInputComponents = inValue; } 3002 uint32_t get_maxTessellationEvaluationOutputComponents() { return m_struct.maxTessellationEvaluationOutputComponents; } 3003 void set_maxTessellationEvaluationOutputComponents(uint32_t inValue) { m_struct.maxTessellationEvaluationOutputComponents = inValue; } 3004 uint32_t get_maxGeometryShaderInvocations() { return m_struct.maxGeometryShaderInvocations; } 3005 void set_maxGeometryShaderInvocations(uint32_t inValue) { m_struct.maxGeometryShaderInvocations = inValue; } 3006 uint32_t get_maxGeometryInputComponents() { return m_struct.maxGeometryInputComponents; } 3007 void set_maxGeometryInputComponents(uint32_t inValue) { m_struct.maxGeometryInputComponents = inValue; } 3008 uint32_t get_maxGeometryOutputComponents() { return m_struct.maxGeometryOutputComponents; } 3009 void set_maxGeometryOutputComponents(uint32_t inValue) { m_struct.maxGeometryOutputComponents = inValue; } 3010 uint32_t get_maxGeometryOutputVertices() { return m_struct.maxGeometryOutputVertices; } 3011 void set_maxGeometryOutputVertices(uint32_t inValue) { m_struct.maxGeometryOutputVertices = inValue; } 3012 uint32_t get_maxGeometryTotalOutputComponents() { return m_struct.maxGeometryTotalOutputComponents; } 3013 void set_maxGeometryTotalOutputComponents(uint32_t inValue) { m_struct.maxGeometryTotalOutputComponents = inValue; } 3014 uint32_t get_maxFragmentInputComponents() { return m_struct.maxFragmentInputComponents; } 3015 void set_maxFragmentInputComponents(uint32_t inValue) { m_struct.maxFragmentInputComponents = inValue; } 3016 uint32_t get_maxFragmentOutputAttachments() { return m_struct.maxFragmentOutputAttachments; } 3017 void set_maxFragmentOutputAttachments(uint32_t inValue) { m_struct.maxFragmentOutputAttachments = inValue; } 3018 uint32_t get_maxFragmentDualSrcAttachments() { return m_struct.maxFragmentDualSrcAttachments; } 3019 void set_maxFragmentDualSrcAttachments(uint32_t inValue) { m_struct.maxFragmentDualSrcAttachments = inValue; } 3020 uint32_t get_maxFragmentCombinedOutputResources() { return m_struct.maxFragmentCombinedOutputResources; } 3021 void set_maxFragmentCombinedOutputResources(uint32_t inValue) { m_struct.maxFragmentCombinedOutputResources = inValue; } 3022 uint32_t get_maxComputeSharedMemorySize() { return m_struct.maxComputeSharedMemorySize; } 3023 void set_maxComputeSharedMemorySize(uint32_t inValue) { m_struct.maxComputeSharedMemorySize = inValue; } 3024 uint32_t get_maxComputeWorkGroupInvocations() { return m_struct.maxComputeWorkGroupInvocations; } 3025 void set_maxComputeWorkGroupInvocations(uint32_t inValue) { m_struct.maxComputeWorkGroupInvocations = inValue; } 3026 uint32_t get_subPixelPrecisionBits() { return m_struct.subPixelPrecisionBits; } 3027 void set_subPixelPrecisionBits(uint32_t inValue) { m_struct.subPixelPrecisionBits = inValue; } 3028 uint32_t get_subTexelPrecisionBits() { return m_struct.subTexelPrecisionBits; } 3029 void set_subTexelPrecisionBits(uint32_t inValue) { m_struct.subTexelPrecisionBits = inValue; } 3030 uint32_t get_mipmapPrecisionBits() { return m_struct.mipmapPrecisionBits; } 3031 void set_mipmapPrecisionBits(uint32_t inValue) { m_struct.mipmapPrecisionBits = inValue; } 3032 uint32_t get_maxDrawIndexedIndexValue() { return m_struct.maxDrawIndexedIndexValue; } 3033 void set_maxDrawIndexedIndexValue(uint32_t inValue) { m_struct.maxDrawIndexedIndexValue = inValue; } 3034 uint32_t get_maxDrawIndirectCount() { return m_struct.maxDrawIndirectCount; } 3035 void set_maxDrawIndirectCount(uint32_t inValue) { m_struct.maxDrawIndirectCount = inValue; } 3036 float get_maxSamplerLodBias() { return m_struct.maxSamplerLodBias; } 3037 void set_maxSamplerLodBias(float inValue) { m_struct.maxSamplerLodBias = inValue; } 3038 float get_maxSamplerAnisotropy() { return m_struct.maxSamplerAnisotropy; } 3039 void set_maxSamplerAnisotropy(float inValue) { m_struct.maxSamplerAnisotropy = inValue; } 3040 uint32_t get_maxViewports() { return m_struct.maxViewports; } 3041 void set_maxViewports(uint32_t inValue) { m_struct.maxViewports = inValue; } 3042 uint32_t get_viewportSubPixelBits() { return m_struct.viewportSubPixelBits; } 3043 void set_viewportSubPixelBits(uint32_t inValue) { m_struct.viewportSubPixelBits = inValue; } 3044 size_t get_minMemoryMapAlignment() { return m_struct.minMemoryMapAlignment; } 3045 void set_minMemoryMapAlignment(size_t inValue) { m_struct.minMemoryMapAlignment = inValue; } 3046 VkDeviceSize get_minTexelBufferOffsetAlignment() { return m_struct.minTexelBufferOffsetAlignment; } 3047 void set_minTexelBufferOffsetAlignment(VkDeviceSize inValue) { m_struct.minTexelBufferOffsetAlignment = inValue; } 3048 VkDeviceSize get_minUniformBufferOffsetAlignment() { return m_struct.minUniformBufferOffsetAlignment; } 3049 void set_minUniformBufferOffsetAlignment(VkDeviceSize inValue) { m_struct.minUniformBufferOffsetAlignment = inValue; } 3050 VkDeviceSize get_minStorageBufferOffsetAlignment() { return m_struct.minStorageBufferOffsetAlignment; } 3051 void set_minStorageBufferOffsetAlignment(VkDeviceSize inValue) { m_struct.minStorageBufferOffsetAlignment = inValue; } 3052 int32_t get_minTexelOffset() { return m_struct.minTexelOffset; } 3053 void set_minTexelOffset(int32_t inValue) { m_struct.minTexelOffset = inValue; } 3054 uint32_t get_maxTexelOffset() { return m_struct.maxTexelOffset; } 3055 void set_maxTexelOffset(uint32_t inValue) { m_struct.maxTexelOffset = inValue; } 3056 int32_t get_minTexelGatherOffset() { return m_struct.minTexelGatherOffset; } 3057 void set_minTexelGatherOffset(int32_t inValue) { m_struct.minTexelGatherOffset = inValue; } 3058 uint32_t get_maxTexelGatherOffset() { return m_struct.maxTexelGatherOffset; } 3059 void set_maxTexelGatherOffset(uint32_t inValue) { m_struct.maxTexelGatherOffset = inValue; } 3060 float get_minInterpolationOffset() { return m_struct.minInterpolationOffset; } 3061 void set_minInterpolationOffset(float inValue) { m_struct.minInterpolationOffset = inValue; } 3062 float get_maxInterpolationOffset() { return m_struct.maxInterpolationOffset; } 3063 void set_maxInterpolationOffset(float inValue) { m_struct.maxInterpolationOffset = inValue; } 3064 uint32_t get_subPixelInterpolationOffsetBits() { return m_struct.subPixelInterpolationOffsetBits; } 3065 void set_subPixelInterpolationOffsetBits(uint32_t inValue) { m_struct.subPixelInterpolationOffsetBits = inValue; } 3066 uint32_t get_maxFramebufferWidth() { return m_struct.maxFramebufferWidth; } 3067 void set_maxFramebufferWidth(uint32_t inValue) { m_struct.maxFramebufferWidth = inValue; } 3068 uint32_t get_maxFramebufferHeight() { return m_struct.maxFramebufferHeight; } 3069 void set_maxFramebufferHeight(uint32_t inValue) { m_struct.maxFramebufferHeight = inValue; } 3070 uint32_t get_maxFramebufferLayers() { return m_struct.maxFramebufferLayers; } 3071 void set_maxFramebufferLayers(uint32_t inValue) { m_struct.maxFramebufferLayers = inValue; } 3072 VkSampleCountFlags get_framebufferColorSampleCounts() { return m_struct.framebufferColorSampleCounts; } 3073 void set_framebufferColorSampleCounts(VkSampleCountFlags inValue) { m_struct.framebufferColorSampleCounts = inValue; } 3074 VkSampleCountFlags get_framebufferDepthSampleCounts() { return m_struct.framebufferDepthSampleCounts; } 3075 void set_framebufferDepthSampleCounts(VkSampleCountFlags inValue) { m_struct.framebufferDepthSampleCounts = inValue; } 3076 VkSampleCountFlags get_framebufferStencilSampleCounts() { return m_struct.framebufferStencilSampleCounts; } 3077 void set_framebufferStencilSampleCounts(VkSampleCountFlags inValue) { m_struct.framebufferStencilSampleCounts = inValue; } 3078 VkSampleCountFlags get_framebufferNoAttachmentsSampleCounts() { return m_struct.framebufferNoAttachmentsSampleCounts; } 3079 void set_framebufferNoAttachmentsSampleCounts(VkSampleCountFlags inValue) { m_struct.framebufferNoAttachmentsSampleCounts = inValue; } 3080 uint32_t get_maxColorAttachments() { return m_struct.maxColorAttachments; } 3081 void set_maxColorAttachments(uint32_t inValue) { m_struct.maxColorAttachments = inValue; } 3082 VkSampleCountFlags get_sampledImageColorSampleCounts() { return m_struct.sampledImageColorSampleCounts; } 3083 void set_sampledImageColorSampleCounts(VkSampleCountFlags inValue) { m_struct.sampledImageColorSampleCounts = inValue; } 3084 VkSampleCountFlags get_sampledImageIntegerSampleCounts() { return m_struct.sampledImageIntegerSampleCounts; } 3085 void set_sampledImageIntegerSampleCounts(VkSampleCountFlags inValue) { m_struct.sampledImageIntegerSampleCounts = inValue; } 3086 VkSampleCountFlags get_sampledImageDepthSampleCounts() { return m_struct.sampledImageDepthSampleCounts; } 3087 void set_sampledImageDepthSampleCounts(VkSampleCountFlags inValue) { m_struct.sampledImageDepthSampleCounts = inValue; } 3088 VkSampleCountFlags get_sampledImageStencilSampleCounts() { return m_struct.sampledImageStencilSampleCounts; } 3089 void set_sampledImageStencilSampleCounts(VkSampleCountFlags inValue) { m_struct.sampledImageStencilSampleCounts = inValue; } 3090 VkSampleCountFlags get_storageImageSampleCounts() { return m_struct.storageImageSampleCounts; } 3091 void set_storageImageSampleCounts(VkSampleCountFlags inValue) { m_struct.storageImageSampleCounts = inValue; } 3092 uint32_t get_maxSampleMaskWords() { return m_struct.maxSampleMaskWords; } 3093 void set_maxSampleMaskWords(uint32_t inValue) { m_struct.maxSampleMaskWords = inValue; } 3094 VkBool32 get_timestampComputeAndGraphics() { return m_struct.timestampComputeAndGraphics; } 3095 void set_timestampComputeAndGraphics(VkBool32 inValue) { m_struct.timestampComputeAndGraphics = inValue; } 3096 float get_timestampPeriod() { return m_struct.timestampPeriod; } 3097 void set_timestampPeriod(float inValue) { m_struct.timestampPeriod = inValue; } 3098 uint32_t get_maxClipDistances() { return m_struct.maxClipDistances; } 3099 void set_maxClipDistances(uint32_t inValue) { m_struct.maxClipDistances = inValue; } 3100 uint32_t get_maxCullDistances() { return m_struct.maxCullDistances; } 3101 void set_maxCullDistances(uint32_t inValue) { m_struct.maxCullDistances = inValue; } 3102 uint32_t get_maxCombinedClipAndCullDistances() { return m_struct.maxCombinedClipAndCullDistances; } 3103 void set_maxCombinedClipAndCullDistances(uint32_t inValue) { m_struct.maxCombinedClipAndCullDistances = inValue; } 3104 uint32_t get_discreteQueuePriorities() { return m_struct.discreteQueuePriorities; } 3105 void set_discreteQueuePriorities(uint32_t inValue) { m_struct.discreteQueuePriorities = inValue; } 3106 float get_pointSizeGranularity() { return m_struct.pointSizeGranularity; } 3107 void set_pointSizeGranularity(float inValue) { m_struct.pointSizeGranularity = inValue; } 3108 float get_lineWidthGranularity() { return m_struct.lineWidthGranularity; } 3109 void set_lineWidthGranularity(float inValue) { m_struct.lineWidthGranularity = inValue; } 3110 VkBool32 get_strictLines() { return m_struct.strictLines; } 3111 void set_strictLines(VkBool32 inValue) { m_struct.strictLines = inValue; } 3112 VkBool32 get_standardSampleLocations() { return m_struct.standardSampleLocations; } 3113 void set_standardSampleLocations(VkBool32 inValue) { m_struct.standardSampleLocations = inValue; } 3114 VkDeviceSize get_optimalBufferCopyOffsetAlignment() { return m_struct.optimalBufferCopyOffsetAlignment; } 3115 void set_optimalBufferCopyOffsetAlignment(VkDeviceSize inValue) { m_struct.optimalBufferCopyOffsetAlignment = inValue; } 3116 VkDeviceSize get_optimalBufferCopyRowPitchAlignment() { return m_struct.optimalBufferCopyRowPitchAlignment; } 3117 void set_optimalBufferCopyRowPitchAlignment(VkDeviceSize inValue) { m_struct.optimalBufferCopyRowPitchAlignment = inValue; } 3118 VkDeviceSize get_nonCoherentAtomSize() { return m_struct.nonCoherentAtomSize; } 3119 void set_nonCoherentAtomSize(VkDeviceSize inValue) { m_struct.nonCoherentAtomSize = inValue; } 3120 3121 3122 private: 3123 VkPhysicalDeviceLimits m_struct; 3124 const VkPhysicalDeviceLimits* m_origStructAddr; 3125 uint32_t m_indent; 3126 const char m_dummy_prefix; 3127 void display_struct_members(); 3128 3129 }; 3130 3131 3132 //class declaration 3133 class vkphysicaldevicememoryproperties_struct_wrapper 3134 { 3135 public: 3136 vkphysicaldevicememoryproperties_struct_wrapper(); 3137 vkphysicaldevicememoryproperties_struct_wrapper(VkPhysicalDeviceMemoryProperties* pInStruct); 3138 vkphysicaldevicememoryproperties_struct_wrapper(const VkPhysicalDeviceMemoryProperties* pInStruct); 3139 3140 virtual ~vkphysicaldevicememoryproperties_struct_wrapper(); 3141 3142 void display_txt(); 3143 void display_single_txt(); 3144 void display_full_txt(); 3145 3146 void set_indent(uint32_t indent) { m_indent = indent; } 3147 uint32_t get_memoryTypeCount() { return m_struct.memoryTypeCount; } 3148 void set_memoryTypeCount(uint32_t inValue) { m_struct.memoryTypeCount = inValue; } 3149 uint32_t get_memoryHeapCount() { return m_struct.memoryHeapCount; } 3150 void set_memoryHeapCount(uint32_t inValue) { m_struct.memoryHeapCount = inValue; } 3151 3152 3153 private: 3154 VkPhysicalDeviceMemoryProperties m_struct; 3155 const VkPhysicalDeviceMemoryProperties* m_origStructAddr; 3156 uint32_t m_indent; 3157 const char m_dummy_prefix; 3158 void display_struct_members(); 3159 3160 }; 3161 3162 3163 //class declaration 3164 class vkphysicaldeviceproperties_struct_wrapper 3165 { 3166 public: 3167 vkphysicaldeviceproperties_struct_wrapper(); 3168 vkphysicaldeviceproperties_struct_wrapper(VkPhysicalDeviceProperties* pInStruct); 3169 vkphysicaldeviceproperties_struct_wrapper(const VkPhysicalDeviceProperties* pInStruct); 3170 3171 virtual ~vkphysicaldeviceproperties_struct_wrapper(); 3172 3173 void display_txt(); 3174 void display_single_txt(); 3175 void display_full_txt(); 3176 3177 void set_indent(uint32_t indent) { m_indent = indent; } 3178 uint32_t get_apiVersion() { return m_struct.apiVersion; } 3179 void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; } 3180 uint32_t get_driverVersion() { return m_struct.driverVersion; } 3181 void set_driverVersion(uint32_t inValue) { m_struct.driverVersion = inValue; } 3182 uint32_t get_vendorID() { return m_struct.vendorID; } 3183 void set_vendorID(uint32_t inValue) { m_struct.vendorID = inValue; } 3184 uint32_t get_deviceID() { return m_struct.deviceID; } 3185 void set_deviceID(uint32_t inValue) { m_struct.deviceID = inValue; } 3186 VkPhysicalDeviceType get_deviceType() { return m_struct.deviceType; } 3187 void set_deviceType(VkPhysicalDeviceType inValue) { m_struct.deviceType = inValue; } 3188 VkPhysicalDeviceLimits get_limits() { return m_struct.limits; } 3189 void set_limits(VkPhysicalDeviceLimits inValue) { m_struct.limits = inValue; } 3190 VkPhysicalDeviceSparseProperties get_sparseProperties() { return m_struct.sparseProperties; } 3191 void set_sparseProperties(VkPhysicalDeviceSparseProperties inValue) { m_struct.sparseProperties = inValue; } 3192 3193 3194 private: 3195 VkPhysicalDeviceProperties m_struct; 3196 const VkPhysicalDeviceProperties* m_origStructAddr; 3197 uint32_t m_indent; 3198 const char m_dummy_prefix; 3199 void display_struct_members(); 3200 3201 }; 3202 3203 3204 //class declaration 3205 class vkphysicaldevicesparseproperties_struct_wrapper 3206 { 3207 public: 3208 vkphysicaldevicesparseproperties_struct_wrapper(); 3209 vkphysicaldevicesparseproperties_struct_wrapper(VkPhysicalDeviceSparseProperties* pInStruct); 3210 vkphysicaldevicesparseproperties_struct_wrapper(const VkPhysicalDeviceSparseProperties* pInStruct); 3211 3212 virtual ~vkphysicaldevicesparseproperties_struct_wrapper(); 3213 3214 void display_txt(); 3215 void display_single_txt(); 3216 void display_full_txt(); 3217 3218 void set_indent(uint32_t indent) { m_indent = indent; } 3219 VkBool32 get_residencyStandard2DBlockShape() { return m_struct.residencyStandard2DBlockShape; } 3220 void set_residencyStandard2DBlockShape(VkBool32 inValue) { m_struct.residencyStandard2DBlockShape = inValue; } 3221 VkBool32 get_residencyStandard2DMultisampleBlockShape() { return m_struct.residencyStandard2DMultisampleBlockShape; } 3222 void set_residencyStandard2DMultisampleBlockShape(VkBool32 inValue) { m_struct.residencyStandard2DMultisampleBlockShape = inValue; } 3223 VkBool32 get_residencyStandard3DBlockShape() { return m_struct.residencyStandard3DBlockShape; } 3224 void set_residencyStandard3DBlockShape(VkBool32 inValue) { m_struct.residencyStandard3DBlockShape = inValue; } 3225 VkBool32 get_residencyAlignedMipSize() { return m_struct.residencyAlignedMipSize; } 3226 void set_residencyAlignedMipSize(VkBool32 inValue) { m_struct.residencyAlignedMipSize = inValue; } 3227 VkBool32 get_residencyNonResidentStrict() { return m_struct.residencyNonResidentStrict; } 3228 void set_residencyNonResidentStrict(VkBool32 inValue) { m_struct.residencyNonResidentStrict = inValue; } 3229 3230 3231 private: 3232 VkPhysicalDeviceSparseProperties m_struct; 3233 const VkPhysicalDeviceSparseProperties* m_origStructAddr; 3234 uint32_t m_indent; 3235 const char m_dummy_prefix; 3236 void display_struct_members(); 3237 3238 }; 3239 3240 3241 //class declaration 3242 class vkpipelinecachecreateinfo_struct_wrapper 3243 { 3244 public: 3245 vkpipelinecachecreateinfo_struct_wrapper(); 3246 vkpipelinecachecreateinfo_struct_wrapper(VkPipelineCacheCreateInfo* pInStruct); 3247 vkpipelinecachecreateinfo_struct_wrapper(const VkPipelineCacheCreateInfo* pInStruct); 3248 3249 virtual ~vkpipelinecachecreateinfo_struct_wrapper(); 3250 3251 void display_txt(); 3252 void display_single_txt(); 3253 void display_full_txt(); 3254 3255 void set_indent(uint32_t indent) { m_indent = indent; } 3256 VkStructureType get_sType() { return m_struct.sType; } 3257 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3258 const void* get_pNext() { return m_struct.pNext; } 3259 VkPipelineCacheCreateFlags get_flags() { return m_struct.flags; } 3260 void set_flags(VkPipelineCacheCreateFlags inValue) { m_struct.flags = inValue; } 3261 size_t get_initialDataSize() { return m_struct.initialDataSize; } 3262 void set_initialDataSize(size_t inValue) { m_struct.initialDataSize = inValue; } 3263 const void* get_pInitialData() { return m_struct.pInitialData; } 3264 3265 3266 private: 3267 VkPipelineCacheCreateInfo m_struct; 3268 const VkPipelineCacheCreateInfo* m_origStructAddr; 3269 uint32_t m_indent; 3270 const char m_dummy_prefix; 3271 void display_struct_members(); 3272 3273 }; 3274 3275 3276 //class declaration 3277 class vkpipelinecolorblendattachmentstate_struct_wrapper 3278 { 3279 public: 3280 vkpipelinecolorblendattachmentstate_struct_wrapper(); 3281 vkpipelinecolorblendattachmentstate_struct_wrapper(VkPipelineColorBlendAttachmentState* pInStruct); 3282 vkpipelinecolorblendattachmentstate_struct_wrapper(const VkPipelineColorBlendAttachmentState* pInStruct); 3283 3284 virtual ~vkpipelinecolorblendattachmentstate_struct_wrapper(); 3285 3286 void display_txt(); 3287 void display_single_txt(); 3288 void display_full_txt(); 3289 3290 void set_indent(uint32_t indent) { m_indent = indent; } 3291 VkBool32 get_blendEnable() { return m_struct.blendEnable; } 3292 void set_blendEnable(VkBool32 inValue) { m_struct.blendEnable = inValue; } 3293 VkBlendFactor get_srcColorBlendFactor() { return m_struct.srcColorBlendFactor; } 3294 void set_srcColorBlendFactor(VkBlendFactor inValue) { m_struct.srcColorBlendFactor = inValue; } 3295 VkBlendFactor get_dstColorBlendFactor() { return m_struct.dstColorBlendFactor; } 3296 void set_dstColorBlendFactor(VkBlendFactor inValue) { m_struct.dstColorBlendFactor = inValue; } 3297 VkBlendOp get_colorBlendOp() { return m_struct.colorBlendOp; } 3298 void set_colorBlendOp(VkBlendOp inValue) { m_struct.colorBlendOp = inValue; } 3299 VkBlendFactor get_srcAlphaBlendFactor() { return m_struct.srcAlphaBlendFactor; } 3300 void set_srcAlphaBlendFactor(VkBlendFactor inValue) { m_struct.srcAlphaBlendFactor = inValue; } 3301 VkBlendFactor get_dstAlphaBlendFactor() { return m_struct.dstAlphaBlendFactor; } 3302 void set_dstAlphaBlendFactor(VkBlendFactor inValue) { m_struct.dstAlphaBlendFactor = inValue; } 3303 VkBlendOp get_alphaBlendOp() { return m_struct.alphaBlendOp; } 3304 void set_alphaBlendOp(VkBlendOp inValue) { m_struct.alphaBlendOp = inValue; } 3305 VkColorComponentFlags get_colorWriteMask() { return m_struct.colorWriteMask; } 3306 void set_colorWriteMask(VkColorComponentFlags inValue) { m_struct.colorWriteMask = inValue; } 3307 3308 3309 private: 3310 VkPipelineColorBlendAttachmentState m_struct; 3311 const VkPipelineColorBlendAttachmentState* m_origStructAddr; 3312 uint32_t m_indent; 3313 const char m_dummy_prefix; 3314 void display_struct_members(); 3315 3316 }; 3317 3318 3319 //class declaration 3320 class vkpipelinecolorblendstatecreateinfo_struct_wrapper 3321 { 3322 public: 3323 vkpipelinecolorblendstatecreateinfo_struct_wrapper(); 3324 vkpipelinecolorblendstatecreateinfo_struct_wrapper(VkPipelineColorBlendStateCreateInfo* pInStruct); 3325 vkpipelinecolorblendstatecreateinfo_struct_wrapper(const VkPipelineColorBlendStateCreateInfo* pInStruct); 3326 3327 virtual ~vkpipelinecolorblendstatecreateinfo_struct_wrapper(); 3328 3329 void display_txt(); 3330 void display_single_txt(); 3331 void display_full_txt(); 3332 3333 void set_indent(uint32_t indent) { m_indent = indent; } 3334 VkStructureType get_sType() { return m_struct.sType; } 3335 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3336 const void* get_pNext() { return m_struct.pNext; } 3337 VkPipelineColorBlendStateCreateFlags get_flags() { return m_struct.flags; } 3338 void set_flags(VkPipelineColorBlendStateCreateFlags inValue) { m_struct.flags = inValue; } 3339 VkBool32 get_logicOpEnable() { return m_struct.logicOpEnable; } 3340 void set_logicOpEnable(VkBool32 inValue) { m_struct.logicOpEnable = inValue; } 3341 VkLogicOp get_logicOp() { return m_struct.logicOp; } 3342 void set_logicOp(VkLogicOp inValue) { m_struct.logicOp = inValue; } 3343 uint32_t get_attachmentCount() { return m_struct.attachmentCount; } 3344 void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; } 3345 3346 3347 private: 3348 VkPipelineColorBlendStateCreateInfo m_struct; 3349 const VkPipelineColorBlendStateCreateInfo* m_origStructAddr; 3350 uint32_t m_indent; 3351 const char m_dummy_prefix; 3352 void display_struct_members(); 3353 3354 }; 3355 3356 3357 //class declaration 3358 class vkpipelinedepthstencilstatecreateinfo_struct_wrapper 3359 { 3360 public: 3361 vkpipelinedepthstencilstatecreateinfo_struct_wrapper(); 3362 vkpipelinedepthstencilstatecreateinfo_struct_wrapper(VkPipelineDepthStencilStateCreateInfo* pInStruct); 3363 vkpipelinedepthstencilstatecreateinfo_struct_wrapper(const VkPipelineDepthStencilStateCreateInfo* pInStruct); 3364 3365 virtual ~vkpipelinedepthstencilstatecreateinfo_struct_wrapper(); 3366 3367 void display_txt(); 3368 void display_single_txt(); 3369 void display_full_txt(); 3370 3371 void set_indent(uint32_t indent) { m_indent = indent; } 3372 VkStructureType get_sType() { return m_struct.sType; } 3373 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3374 const void* get_pNext() { return m_struct.pNext; } 3375 VkPipelineDepthStencilStateCreateFlags get_flags() { return m_struct.flags; } 3376 void set_flags(VkPipelineDepthStencilStateCreateFlags inValue) { m_struct.flags = inValue; } 3377 VkBool32 get_depthTestEnable() { return m_struct.depthTestEnable; } 3378 void set_depthTestEnable(VkBool32 inValue) { m_struct.depthTestEnable = inValue; } 3379 VkBool32 get_depthWriteEnable() { return m_struct.depthWriteEnable; } 3380 void set_depthWriteEnable(VkBool32 inValue) { m_struct.depthWriteEnable = inValue; } 3381 VkCompareOp get_depthCompareOp() { return m_struct.depthCompareOp; } 3382 void set_depthCompareOp(VkCompareOp inValue) { m_struct.depthCompareOp = inValue; } 3383 VkBool32 get_depthBoundsTestEnable() { return m_struct.depthBoundsTestEnable; } 3384 void set_depthBoundsTestEnable(VkBool32 inValue) { m_struct.depthBoundsTestEnable = inValue; } 3385 VkBool32 get_stencilTestEnable() { return m_struct.stencilTestEnable; } 3386 void set_stencilTestEnable(VkBool32 inValue) { m_struct.stencilTestEnable = inValue; } 3387 VkStencilOpState get_front() { return m_struct.front; } 3388 void set_front(VkStencilOpState inValue) { m_struct.front = inValue; } 3389 VkStencilOpState get_back() { return m_struct.back; } 3390 void set_back(VkStencilOpState inValue) { m_struct.back = inValue; } 3391 float get_minDepthBounds() { return m_struct.minDepthBounds; } 3392 void set_minDepthBounds(float inValue) { m_struct.minDepthBounds = inValue; } 3393 float get_maxDepthBounds() { return m_struct.maxDepthBounds; } 3394 void set_maxDepthBounds(float inValue) { m_struct.maxDepthBounds = inValue; } 3395 3396 3397 private: 3398 VkPipelineDepthStencilStateCreateInfo m_struct; 3399 const VkPipelineDepthStencilStateCreateInfo* m_origStructAddr; 3400 uint32_t m_indent; 3401 const char m_dummy_prefix; 3402 void display_struct_members(); 3403 3404 }; 3405 3406 3407 //class declaration 3408 class vkpipelinedynamicstatecreateinfo_struct_wrapper 3409 { 3410 public: 3411 vkpipelinedynamicstatecreateinfo_struct_wrapper(); 3412 vkpipelinedynamicstatecreateinfo_struct_wrapper(VkPipelineDynamicStateCreateInfo* pInStruct); 3413 vkpipelinedynamicstatecreateinfo_struct_wrapper(const VkPipelineDynamicStateCreateInfo* pInStruct); 3414 3415 virtual ~vkpipelinedynamicstatecreateinfo_struct_wrapper(); 3416 3417 void display_txt(); 3418 void display_single_txt(); 3419 void display_full_txt(); 3420 3421 void set_indent(uint32_t indent) { m_indent = indent; } 3422 VkStructureType get_sType() { return m_struct.sType; } 3423 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3424 const void* get_pNext() { return m_struct.pNext; } 3425 VkPipelineDynamicStateCreateFlags get_flags() { return m_struct.flags; } 3426 void set_flags(VkPipelineDynamicStateCreateFlags inValue) { m_struct.flags = inValue; } 3427 uint32_t get_dynamicStateCount() { return m_struct.dynamicStateCount; } 3428 void set_dynamicStateCount(uint32_t inValue) { m_struct.dynamicStateCount = inValue; } 3429 3430 3431 private: 3432 VkPipelineDynamicStateCreateInfo m_struct; 3433 const VkPipelineDynamicStateCreateInfo* m_origStructAddr; 3434 uint32_t m_indent; 3435 const char m_dummy_prefix; 3436 void display_struct_members(); 3437 3438 }; 3439 3440 3441 //class declaration 3442 class vkpipelineinputassemblystatecreateinfo_struct_wrapper 3443 { 3444 public: 3445 vkpipelineinputassemblystatecreateinfo_struct_wrapper(); 3446 vkpipelineinputassemblystatecreateinfo_struct_wrapper(VkPipelineInputAssemblyStateCreateInfo* pInStruct); 3447 vkpipelineinputassemblystatecreateinfo_struct_wrapper(const VkPipelineInputAssemblyStateCreateInfo* pInStruct); 3448 3449 virtual ~vkpipelineinputassemblystatecreateinfo_struct_wrapper(); 3450 3451 void display_txt(); 3452 void display_single_txt(); 3453 void display_full_txt(); 3454 3455 void set_indent(uint32_t indent) { m_indent = indent; } 3456 VkStructureType get_sType() { return m_struct.sType; } 3457 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3458 const void* get_pNext() { return m_struct.pNext; } 3459 VkPipelineInputAssemblyStateCreateFlags get_flags() { return m_struct.flags; } 3460 void set_flags(VkPipelineInputAssemblyStateCreateFlags inValue) { m_struct.flags = inValue; } 3461 VkPrimitiveTopology get_topology() { return m_struct.topology; } 3462 void set_topology(VkPrimitiveTopology inValue) { m_struct.topology = inValue; } 3463 VkBool32 get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; } 3464 void set_primitiveRestartEnable(VkBool32 inValue) { m_struct.primitiveRestartEnable = inValue; } 3465 3466 3467 private: 3468 VkPipelineInputAssemblyStateCreateInfo m_struct; 3469 const VkPipelineInputAssemblyStateCreateInfo* m_origStructAddr; 3470 uint32_t m_indent; 3471 const char m_dummy_prefix; 3472 void display_struct_members(); 3473 3474 }; 3475 3476 3477 //class declaration 3478 class vkpipelinelayoutcreateinfo_struct_wrapper 3479 { 3480 public: 3481 vkpipelinelayoutcreateinfo_struct_wrapper(); 3482 vkpipelinelayoutcreateinfo_struct_wrapper(VkPipelineLayoutCreateInfo* pInStruct); 3483 vkpipelinelayoutcreateinfo_struct_wrapper(const VkPipelineLayoutCreateInfo* pInStruct); 3484 3485 virtual ~vkpipelinelayoutcreateinfo_struct_wrapper(); 3486 3487 void display_txt(); 3488 void display_single_txt(); 3489 void display_full_txt(); 3490 3491 void set_indent(uint32_t indent) { m_indent = indent; } 3492 VkStructureType get_sType() { return m_struct.sType; } 3493 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3494 const void* get_pNext() { return m_struct.pNext; } 3495 VkPipelineLayoutCreateFlags get_flags() { return m_struct.flags; } 3496 void set_flags(VkPipelineLayoutCreateFlags inValue) { m_struct.flags = inValue; } 3497 uint32_t get_setLayoutCount() { return m_struct.setLayoutCount; } 3498 void set_setLayoutCount(uint32_t inValue) { m_struct.setLayoutCount = inValue; } 3499 uint32_t get_pushConstantRangeCount() { return m_struct.pushConstantRangeCount; } 3500 void set_pushConstantRangeCount(uint32_t inValue) { m_struct.pushConstantRangeCount = inValue; } 3501 3502 3503 private: 3504 VkPipelineLayoutCreateInfo m_struct; 3505 const VkPipelineLayoutCreateInfo* m_origStructAddr; 3506 uint32_t m_indent; 3507 const char m_dummy_prefix; 3508 void display_struct_members(); 3509 3510 }; 3511 3512 3513 //class declaration 3514 class vkpipelinemultisamplestatecreateinfo_struct_wrapper 3515 { 3516 public: 3517 vkpipelinemultisamplestatecreateinfo_struct_wrapper(); 3518 vkpipelinemultisamplestatecreateinfo_struct_wrapper(VkPipelineMultisampleStateCreateInfo* pInStruct); 3519 vkpipelinemultisamplestatecreateinfo_struct_wrapper(const VkPipelineMultisampleStateCreateInfo* pInStruct); 3520 3521 virtual ~vkpipelinemultisamplestatecreateinfo_struct_wrapper(); 3522 3523 void display_txt(); 3524 void display_single_txt(); 3525 void display_full_txt(); 3526 3527 void set_indent(uint32_t indent) { m_indent = indent; } 3528 VkStructureType get_sType() { return m_struct.sType; } 3529 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3530 const void* get_pNext() { return m_struct.pNext; } 3531 VkPipelineMultisampleStateCreateFlags get_flags() { return m_struct.flags; } 3532 void set_flags(VkPipelineMultisampleStateCreateFlags inValue) { m_struct.flags = inValue; } 3533 VkSampleCountFlagBits get_rasterizationSamples() { return m_struct.rasterizationSamples; } 3534 void set_rasterizationSamples(VkSampleCountFlagBits inValue) { m_struct.rasterizationSamples = inValue; } 3535 VkBool32 get_sampleShadingEnable() { return m_struct.sampleShadingEnable; } 3536 void set_sampleShadingEnable(VkBool32 inValue) { m_struct.sampleShadingEnable = inValue; } 3537 float get_minSampleShading() { return m_struct.minSampleShading; } 3538 void set_minSampleShading(float inValue) { m_struct.minSampleShading = inValue; } 3539 const VkSampleMask* get_pSampleMask() { return m_struct.pSampleMask; } 3540 VkBool32 get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; } 3541 void set_alphaToCoverageEnable(VkBool32 inValue) { m_struct.alphaToCoverageEnable = inValue; } 3542 VkBool32 get_alphaToOneEnable() { return m_struct.alphaToOneEnable; } 3543 void set_alphaToOneEnable(VkBool32 inValue) { m_struct.alphaToOneEnable = inValue; } 3544 3545 3546 private: 3547 VkPipelineMultisampleStateCreateInfo m_struct; 3548 const VkPipelineMultisampleStateCreateInfo* m_origStructAddr; 3549 uint32_t m_indent; 3550 const char m_dummy_prefix; 3551 void display_struct_members(); 3552 3553 }; 3554 3555 3556 //class declaration 3557 class vkpipelinerasterizationstatecreateinfo_struct_wrapper 3558 { 3559 public: 3560 vkpipelinerasterizationstatecreateinfo_struct_wrapper(); 3561 vkpipelinerasterizationstatecreateinfo_struct_wrapper(VkPipelineRasterizationStateCreateInfo* pInStruct); 3562 vkpipelinerasterizationstatecreateinfo_struct_wrapper(const VkPipelineRasterizationStateCreateInfo* pInStruct); 3563 3564 virtual ~vkpipelinerasterizationstatecreateinfo_struct_wrapper(); 3565 3566 void display_txt(); 3567 void display_single_txt(); 3568 void display_full_txt(); 3569 3570 void set_indent(uint32_t indent) { m_indent = indent; } 3571 VkStructureType get_sType() { return m_struct.sType; } 3572 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3573 const void* get_pNext() { return m_struct.pNext; } 3574 VkPipelineRasterizationStateCreateFlags get_flags() { return m_struct.flags; } 3575 void set_flags(VkPipelineRasterizationStateCreateFlags inValue) { m_struct.flags = inValue; } 3576 VkBool32 get_depthClampEnable() { return m_struct.depthClampEnable; } 3577 void set_depthClampEnable(VkBool32 inValue) { m_struct.depthClampEnable = inValue; } 3578 VkBool32 get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; } 3579 void set_rasterizerDiscardEnable(VkBool32 inValue) { m_struct.rasterizerDiscardEnable = inValue; } 3580 VkPolygonMode get_polygonMode() { return m_struct.polygonMode; } 3581 void set_polygonMode(VkPolygonMode inValue) { m_struct.polygonMode = inValue; } 3582 VkCullModeFlags get_cullMode() { return m_struct.cullMode; } 3583 void set_cullMode(VkCullModeFlags inValue) { m_struct.cullMode = inValue; } 3584 VkFrontFace get_frontFace() { return m_struct.frontFace; } 3585 void set_frontFace(VkFrontFace inValue) { m_struct.frontFace = inValue; } 3586 VkBool32 get_depthBiasEnable() { return m_struct.depthBiasEnable; } 3587 void set_depthBiasEnable(VkBool32 inValue) { m_struct.depthBiasEnable = inValue; } 3588 float get_depthBiasConstantFactor() { return m_struct.depthBiasConstantFactor; } 3589 void set_depthBiasConstantFactor(float inValue) { m_struct.depthBiasConstantFactor = inValue; } 3590 float get_depthBiasClamp() { return m_struct.depthBiasClamp; } 3591 void set_depthBiasClamp(float inValue) { m_struct.depthBiasClamp = inValue; } 3592 float get_depthBiasSlopeFactor() { return m_struct.depthBiasSlopeFactor; } 3593 void set_depthBiasSlopeFactor(float inValue) { m_struct.depthBiasSlopeFactor = inValue; } 3594 float get_lineWidth() { return m_struct.lineWidth; } 3595 void set_lineWidth(float inValue) { m_struct.lineWidth = inValue; } 3596 3597 3598 private: 3599 VkPipelineRasterizationStateCreateInfo m_struct; 3600 const VkPipelineRasterizationStateCreateInfo* m_origStructAddr; 3601 uint32_t m_indent; 3602 const char m_dummy_prefix; 3603 void display_struct_members(); 3604 3605 }; 3606 3607 3608 //class declaration 3609 class vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper 3610 { 3611 public: 3612 vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper(); 3613 vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper(VkPipelineRasterizationStateRasterizationOrderAMD* pInStruct); 3614 vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper(const VkPipelineRasterizationStateRasterizationOrderAMD* pInStruct); 3615 3616 virtual ~vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper(); 3617 3618 void display_txt(); 3619 void display_single_txt(); 3620 void display_full_txt(); 3621 3622 void set_indent(uint32_t indent) { m_indent = indent; } 3623 VkStructureType get_sType() { return m_struct.sType; } 3624 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3625 const void* get_pNext() { return m_struct.pNext; } 3626 VkRasterizationOrderAMD get_rasterizationOrder() { return m_struct.rasterizationOrder; } 3627 void set_rasterizationOrder(VkRasterizationOrderAMD inValue) { m_struct.rasterizationOrder = inValue; } 3628 3629 3630 private: 3631 VkPipelineRasterizationStateRasterizationOrderAMD m_struct; 3632 const VkPipelineRasterizationStateRasterizationOrderAMD* m_origStructAddr; 3633 uint32_t m_indent; 3634 const char m_dummy_prefix; 3635 void display_struct_members(); 3636 3637 }; 3638 3639 3640 //class declaration 3641 class vkpipelineshaderstagecreateinfo_struct_wrapper 3642 { 3643 public: 3644 vkpipelineshaderstagecreateinfo_struct_wrapper(); 3645 vkpipelineshaderstagecreateinfo_struct_wrapper(VkPipelineShaderStageCreateInfo* pInStruct); 3646 vkpipelineshaderstagecreateinfo_struct_wrapper(const VkPipelineShaderStageCreateInfo* pInStruct); 3647 3648 virtual ~vkpipelineshaderstagecreateinfo_struct_wrapper(); 3649 3650 void display_txt(); 3651 void display_single_txt(); 3652 void display_full_txt(); 3653 3654 void set_indent(uint32_t indent) { m_indent = indent; } 3655 VkStructureType get_sType() { return m_struct.sType; } 3656 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3657 const void* get_pNext() { return m_struct.pNext; } 3658 VkPipelineShaderStageCreateFlags get_flags() { return m_struct.flags; } 3659 void set_flags(VkPipelineShaderStageCreateFlags inValue) { m_struct.flags = inValue; } 3660 VkShaderStageFlagBits get_stage() { return m_struct.stage; } 3661 void set_stage(VkShaderStageFlagBits inValue) { m_struct.stage = inValue; } 3662 VkShaderModule get_module() { return m_struct.module; } 3663 void set_module(VkShaderModule inValue) { m_struct.module = inValue; } 3664 const char* get_pName() { return m_struct.pName; } 3665 const VkSpecializationInfo* get_pSpecializationInfo() { return m_struct.pSpecializationInfo; } 3666 3667 3668 private: 3669 VkPipelineShaderStageCreateInfo m_struct; 3670 const VkPipelineShaderStageCreateInfo* m_origStructAddr; 3671 uint32_t m_indent; 3672 const char m_dummy_prefix; 3673 void display_struct_members(); 3674 3675 }; 3676 3677 3678 //class declaration 3679 class vkpipelinetessellationstatecreateinfo_struct_wrapper 3680 { 3681 public: 3682 vkpipelinetessellationstatecreateinfo_struct_wrapper(); 3683 vkpipelinetessellationstatecreateinfo_struct_wrapper(VkPipelineTessellationStateCreateInfo* pInStruct); 3684 vkpipelinetessellationstatecreateinfo_struct_wrapper(const VkPipelineTessellationStateCreateInfo* pInStruct); 3685 3686 virtual ~vkpipelinetessellationstatecreateinfo_struct_wrapper(); 3687 3688 void display_txt(); 3689 void display_single_txt(); 3690 void display_full_txt(); 3691 3692 void set_indent(uint32_t indent) { m_indent = indent; } 3693 VkStructureType get_sType() { return m_struct.sType; } 3694 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3695 const void* get_pNext() { return m_struct.pNext; } 3696 VkPipelineTessellationStateCreateFlags get_flags() { return m_struct.flags; } 3697 void set_flags(VkPipelineTessellationStateCreateFlags inValue) { m_struct.flags = inValue; } 3698 uint32_t get_patchControlPoints() { return m_struct.patchControlPoints; } 3699 void set_patchControlPoints(uint32_t inValue) { m_struct.patchControlPoints = inValue; } 3700 3701 3702 private: 3703 VkPipelineTessellationStateCreateInfo m_struct; 3704 const VkPipelineTessellationStateCreateInfo* m_origStructAddr; 3705 uint32_t m_indent; 3706 const char m_dummy_prefix; 3707 void display_struct_members(); 3708 3709 }; 3710 3711 3712 //class declaration 3713 class vkpipelinevertexinputstatecreateinfo_struct_wrapper 3714 { 3715 public: 3716 vkpipelinevertexinputstatecreateinfo_struct_wrapper(); 3717 vkpipelinevertexinputstatecreateinfo_struct_wrapper(VkPipelineVertexInputStateCreateInfo* pInStruct); 3718 vkpipelinevertexinputstatecreateinfo_struct_wrapper(const VkPipelineVertexInputStateCreateInfo* pInStruct); 3719 3720 virtual ~vkpipelinevertexinputstatecreateinfo_struct_wrapper(); 3721 3722 void display_txt(); 3723 void display_single_txt(); 3724 void display_full_txt(); 3725 3726 void set_indent(uint32_t indent) { m_indent = indent; } 3727 VkStructureType get_sType() { return m_struct.sType; } 3728 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3729 const void* get_pNext() { return m_struct.pNext; } 3730 VkPipelineVertexInputStateCreateFlags get_flags() { return m_struct.flags; } 3731 void set_flags(VkPipelineVertexInputStateCreateFlags inValue) { m_struct.flags = inValue; } 3732 uint32_t get_vertexBindingDescriptionCount() { return m_struct.vertexBindingDescriptionCount; } 3733 void set_vertexBindingDescriptionCount(uint32_t inValue) { m_struct.vertexBindingDescriptionCount = inValue; } 3734 uint32_t get_vertexAttributeDescriptionCount() { return m_struct.vertexAttributeDescriptionCount; } 3735 void set_vertexAttributeDescriptionCount(uint32_t inValue) { m_struct.vertexAttributeDescriptionCount = inValue; } 3736 3737 3738 private: 3739 VkPipelineVertexInputStateCreateInfo m_struct; 3740 const VkPipelineVertexInputStateCreateInfo* m_origStructAddr; 3741 uint32_t m_indent; 3742 const char m_dummy_prefix; 3743 void display_struct_members(); 3744 3745 }; 3746 3747 3748 //class declaration 3749 class vkpipelineviewportstatecreateinfo_struct_wrapper 3750 { 3751 public: 3752 vkpipelineviewportstatecreateinfo_struct_wrapper(); 3753 vkpipelineviewportstatecreateinfo_struct_wrapper(VkPipelineViewportStateCreateInfo* pInStruct); 3754 vkpipelineviewportstatecreateinfo_struct_wrapper(const VkPipelineViewportStateCreateInfo* pInStruct); 3755 3756 virtual ~vkpipelineviewportstatecreateinfo_struct_wrapper(); 3757 3758 void display_txt(); 3759 void display_single_txt(); 3760 void display_full_txt(); 3761 3762 void set_indent(uint32_t indent) { m_indent = indent; } 3763 VkStructureType get_sType() { return m_struct.sType; } 3764 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3765 const void* get_pNext() { return m_struct.pNext; } 3766 VkPipelineViewportStateCreateFlags get_flags() { return m_struct.flags; } 3767 void set_flags(VkPipelineViewportStateCreateFlags inValue) { m_struct.flags = inValue; } 3768 uint32_t get_viewportCount() { return m_struct.viewportCount; } 3769 void set_viewportCount(uint32_t inValue) { m_struct.viewportCount = inValue; } 3770 uint32_t get_scissorCount() { return m_struct.scissorCount; } 3771 void set_scissorCount(uint32_t inValue) { m_struct.scissorCount = inValue; } 3772 3773 3774 private: 3775 VkPipelineViewportStateCreateInfo m_struct; 3776 const VkPipelineViewportStateCreateInfo* m_origStructAddr; 3777 uint32_t m_indent; 3778 const char m_dummy_prefix; 3779 void display_struct_members(); 3780 3781 }; 3782 3783 3784 //class declaration 3785 class vkpresentinfokhr_struct_wrapper 3786 { 3787 public: 3788 vkpresentinfokhr_struct_wrapper(); 3789 vkpresentinfokhr_struct_wrapper(VkPresentInfoKHR* pInStruct); 3790 vkpresentinfokhr_struct_wrapper(const VkPresentInfoKHR* pInStruct); 3791 3792 virtual ~vkpresentinfokhr_struct_wrapper(); 3793 3794 void display_txt(); 3795 void display_single_txt(); 3796 void display_full_txt(); 3797 3798 void set_indent(uint32_t indent) { m_indent = indent; } 3799 VkStructureType get_sType() { return m_struct.sType; } 3800 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3801 const void* get_pNext() { return m_struct.pNext; } 3802 uint32_t get_waitSemaphoreCount() { return m_struct.waitSemaphoreCount; } 3803 void set_waitSemaphoreCount(uint32_t inValue) { m_struct.waitSemaphoreCount = inValue; } 3804 uint32_t get_swapchainCount() { return m_struct.swapchainCount; } 3805 void set_swapchainCount(uint32_t inValue) { m_struct.swapchainCount = inValue; } 3806 VkResult* get_pResults() { return m_struct.pResults; } 3807 void set_pResults(VkResult* inValue) { m_struct.pResults = inValue; } 3808 3809 3810 private: 3811 VkPresentInfoKHR m_struct; 3812 const VkPresentInfoKHR* m_origStructAddr; 3813 uint32_t m_indent; 3814 const char m_dummy_prefix; 3815 void display_struct_members(); 3816 3817 }; 3818 3819 3820 //class declaration 3821 class vkpushconstantrange_struct_wrapper 3822 { 3823 public: 3824 vkpushconstantrange_struct_wrapper(); 3825 vkpushconstantrange_struct_wrapper(VkPushConstantRange* pInStruct); 3826 vkpushconstantrange_struct_wrapper(const VkPushConstantRange* pInStruct); 3827 3828 virtual ~vkpushconstantrange_struct_wrapper(); 3829 3830 void display_txt(); 3831 void display_single_txt(); 3832 void display_full_txt(); 3833 3834 void set_indent(uint32_t indent) { m_indent = indent; } 3835 VkShaderStageFlags get_stageFlags() { return m_struct.stageFlags; } 3836 void set_stageFlags(VkShaderStageFlags inValue) { m_struct.stageFlags = inValue; } 3837 uint32_t get_offset() { return m_struct.offset; } 3838 void set_offset(uint32_t inValue) { m_struct.offset = inValue; } 3839 uint32_t get_size() { return m_struct.size; } 3840 void set_size(uint32_t inValue) { m_struct.size = inValue; } 3841 3842 3843 private: 3844 VkPushConstantRange m_struct; 3845 const VkPushConstantRange* m_origStructAddr; 3846 uint32_t m_indent; 3847 const char m_dummy_prefix; 3848 void display_struct_members(); 3849 3850 }; 3851 3852 3853 //class declaration 3854 class vkquerypoolcreateinfo_struct_wrapper 3855 { 3856 public: 3857 vkquerypoolcreateinfo_struct_wrapper(); 3858 vkquerypoolcreateinfo_struct_wrapper(VkQueryPoolCreateInfo* pInStruct); 3859 vkquerypoolcreateinfo_struct_wrapper(const VkQueryPoolCreateInfo* pInStruct); 3860 3861 virtual ~vkquerypoolcreateinfo_struct_wrapper(); 3862 3863 void display_txt(); 3864 void display_single_txt(); 3865 void display_full_txt(); 3866 3867 void set_indent(uint32_t indent) { m_indent = indent; } 3868 VkStructureType get_sType() { return m_struct.sType; } 3869 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3870 const void* get_pNext() { return m_struct.pNext; } 3871 VkQueryPoolCreateFlags get_flags() { return m_struct.flags; } 3872 void set_flags(VkQueryPoolCreateFlags inValue) { m_struct.flags = inValue; } 3873 VkQueryType get_queryType() { return m_struct.queryType; } 3874 void set_queryType(VkQueryType inValue) { m_struct.queryType = inValue; } 3875 uint32_t get_queryCount() { return m_struct.queryCount; } 3876 void set_queryCount(uint32_t inValue) { m_struct.queryCount = inValue; } 3877 VkQueryPipelineStatisticFlags get_pipelineStatistics() { return m_struct.pipelineStatistics; } 3878 void set_pipelineStatistics(VkQueryPipelineStatisticFlags inValue) { m_struct.pipelineStatistics = inValue; } 3879 3880 3881 private: 3882 VkQueryPoolCreateInfo m_struct; 3883 const VkQueryPoolCreateInfo* m_origStructAddr; 3884 uint32_t m_indent; 3885 const char m_dummy_prefix; 3886 void display_struct_members(); 3887 3888 }; 3889 3890 3891 //class declaration 3892 class vkqueuefamilyproperties_struct_wrapper 3893 { 3894 public: 3895 vkqueuefamilyproperties_struct_wrapper(); 3896 vkqueuefamilyproperties_struct_wrapper(VkQueueFamilyProperties* pInStruct); 3897 vkqueuefamilyproperties_struct_wrapper(const VkQueueFamilyProperties* pInStruct); 3898 3899 virtual ~vkqueuefamilyproperties_struct_wrapper(); 3900 3901 void display_txt(); 3902 void display_single_txt(); 3903 void display_full_txt(); 3904 3905 void set_indent(uint32_t indent) { m_indent = indent; } 3906 VkQueueFlags get_queueFlags() { return m_struct.queueFlags; } 3907 void set_queueFlags(VkQueueFlags inValue) { m_struct.queueFlags = inValue; } 3908 uint32_t get_queueCount() { return m_struct.queueCount; } 3909 void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; } 3910 uint32_t get_timestampValidBits() { return m_struct.timestampValidBits; } 3911 void set_timestampValidBits(uint32_t inValue) { m_struct.timestampValidBits = inValue; } 3912 VkExtent3D get_minImageTransferGranularity() { return m_struct.minImageTransferGranularity; } 3913 void set_minImageTransferGranularity(VkExtent3D inValue) { m_struct.minImageTransferGranularity = inValue; } 3914 3915 3916 private: 3917 VkQueueFamilyProperties m_struct; 3918 const VkQueueFamilyProperties* m_origStructAddr; 3919 uint32_t m_indent; 3920 const char m_dummy_prefix; 3921 void display_struct_members(); 3922 3923 }; 3924 3925 3926 //class declaration 3927 class vkrect2d_struct_wrapper 3928 { 3929 public: 3930 vkrect2d_struct_wrapper(); 3931 vkrect2d_struct_wrapper(VkRect2D* pInStruct); 3932 vkrect2d_struct_wrapper(const VkRect2D* pInStruct); 3933 3934 virtual ~vkrect2d_struct_wrapper(); 3935 3936 void display_txt(); 3937 void display_single_txt(); 3938 void display_full_txt(); 3939 3940 void set_indent(uint32_t indent) { m_indent = indent; } 3941 VkOffset2D get_offset() { return m_struct.offset; } 3942 void set_offset(VkOffset2D inValue) { m_struct.offset = inValue; } 3943 VkExtent2D get_extent() { return m_struct.extent; } 3944 void set_extent(VkExtent2D inValue) { m_struct.extent = inValue; } 3945 3946 3947 private: 3948 VkRect2D m_struct; 3949 const VkRect2D* m_origStructAddr; 3950 uint32_t m_indent; 3951 const char m_dummy_prefix; 3952 void display_struct_members(); 3953 3954 }; 3955 3956 3957 //class declaration 3958 class vkrenderpassbegininfo_struct_wrapper 3959 { 3960 public: 3961 vkrenderpassbegininfo_struct_wrapper(); 3962 vkrenderpassbegininfo_struct_wrapper(VkRenderPassBeginInfo* pInStruct); 3963 vkrenderpassbegininfo_struct_wrapper(const VkRenderPassBeginInfo* pInStruct); 3964 3965 virtual ~vkrenderpassbegininfo_struct_wrapper(); 3966 3967 void display_txt(); 3968 void display_single_txt(); 3969 void display_full_txt(); 3970 3971 void set_indent(uint32_t indent) { m_indent = indent; } 3972 VkStructureType get_sType() { return m_struct.sType; } 3973 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3974 const void* get_pNext() { return m_struct.pNext; } 3975 VkRenderPass get_renderPass() { return m_struct.renderPass; } 3976 void set_renderPass(VkRenderPass inValue) { m_struct.renderPass = inValue; } 3977 VkFramebuffer get_framebuffer() { return m_struct.framebuffer; } 3978 void set_framebuffer(VkFramebuffer inValue) { m_struct.framebuffer = inValue; } 3979 VkRect2D get_renderArea() { return m_struct.renderArea; } 3980 void set_renderArea(VkRect2D inValue) { m_struct.renderArea = inValue; } 3981 uint32_t get_clearValueCount() { return m_struct.clearValueCount; } 3982 void set_clearValueCount(uint32_t inValue) { m_struct.clearValueCount = inValue; } 3983 3984 3985 private: 3986 VkRenderPassBeginInfo m_struct; 3987 const VkRenderPassBeginInfo* m_origStructAddr; 3988 uint32_t m_indent; 3989 const char m_dummy_prefix; 3990 void display_struct_members(); 3991 3992 }; 3993 3994 3995 //class declaration 3996 class vkrenderpasscreateinfo_struct_wrapper 3997 { 3998 public: 3999 vkrenderpasscreateinfo_struct_wrapper(); 4000 vkrenderpasscreateinfo_struct_wrapper(VkRenderPassCreateInfo* pInStruct); 4001 vkrenderpasscreateinfo_struct_wrapper(const VkRenderPassCreateInfo* pInStruct); 4002 4003 virtual ~vkrenderpasscreateinfo_struct_wrapper(); 4004 4005 void display_txt(); 4006 void display_single_txt(); 4007 void display_full_txt(); 4008 4009 void set_indent(uint32_t indent) { m_indent = indent; } 4010 VkStructureType get_sType() { return m_struct.sType; } 4011 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4012 const void* get_pNext() { return m_struct.pNext; } 4013 VkRenderPassCreateFlags get_flags() { return m_struct.flags; } 4014 void set_flags(VkRenderPassCreateFlags inValue) { m_struct.flags = inValue; } 4015 uint32_t get_attachmentCount() { return m_struct.attachmentCount; } 4016 void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; } 4017 uint32_t get_subpassCount() { return m_struct.subpassCount; } 4018 void set_subpassCount(uint32_t inValue) { m_struct.subpassCount = inValue; } 4019 uint32_t get_dependencyCount() { return m_struct.dependencyCount; } 4020 void set_dependencyCount(uint32_t inValue) { m_struct.dependencyCount = inValue; } 4021 4022 4023 private: 4024 VkRenderPassCreateInfo m_struct; 4025 const VkRenderPassCreateInfo* m_origStructAddr; 4026 uint32_t m_indent; 4027 const char m_dummy_prefix; 4028 void display_struct_members(); 4029 4030 }; 4031 4032 4033 //class declaration 4034 class vksamplercreateinfo_struct_wrapper 4035 { 4036 public: 4037 vksamplercreateinfo_struct_wrapper(); 4038 vksamplercreateinfo_struct_wrapper(VkSamplerCreateInfo* pInStruct); 4039 vksamplercreateinfo_struct_wrapper(const VkSamplerCreateInfo* pInStruct); 4040 4041 virtual ~vksamplercreateinfo_struct_wrapper(); 4042 4043 void display_txt(); 4044 void display_single_txt(); 4045 void display_full_txt(); 4046 4047 void set_indent(uint32_t indent) { m_indent = indent; } 4048 VkStructureType get_sType() { return m_struct.sType; } 4049 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4050 const void* get_pNext() { return m_struct.pNext; } 4051 VkSamplerCreateFlags get_flags() { return m_struct.flags; } 4052 void set_flags(VkSamplerCreateFlags inValue) { m_struct.flags = inValue; } 4053 VkFilter get_magFilter() { return m_struct.magFilter; } 4054 void set_magFilter(VkFilter inValue) { m_struct.magFilter = inValue; } 4055 VkFilter get_minFilter() { return m_struct.minFilter; } 4056 void set_minFilter(VkFilter inValue) { m_struct.minFilter = inValue; } 4057 VkSamplerMipmapMode get_mipmapMode() { return m_struct.mipmapMode; } 4058 void set_mipmapMode(VkSamplerMipmapMode inValue) { m_struct.mipmapMode = inValue; } 4059 VkSamplerAddressMode get_addressModeU() { return m_struct.addressModeU; } 4060 void set_addressModeU(VkSamplerAddressMode inValue) { m_struct.addressModeU = inValue; } 4061 VkSamplerAddressMode get_addressModeV() { return m_struct.addressModeV; } 4062 void set_addressModeV(VkSamplerAddressMode inValue) { m_struct.addressModeV = inValue; } 4063 VkSamplerAddressMode get_addressModeW() { return m_struct.addressModeW; } 4064 void set_addressModeW(VkSamplerAddressMode inValue) { m_struct.addressModeW = inValue; } 4065 float get_mipLodBias() { return m_struct.mipLodBias; } 4066 void set_mipLodBias(float inValue) { m_struct.mipLodBias = inValue; } 4067 VkBool32 get_anisotropyEnable() { return m_struct.anisotropyEnable; } 4068 void set_anisotropyEnable(VkBool32 inValue) { m_struct.anisotropyEnable = inValue; } 4069 float get_maxAnisotropy() { return m_struct.maxAnisotropy; } 4070 void set_maxAnisotropy(float inValue) { m_struct.maxAnisotropy = inValue; } 4071 VkBool32 get_compareEnable() { return m_struct.compareEnable; } 4072 void set_compareEnable(VkBool32 inValue) { m_struct.compareEnable = inValue; } 4073 VkCompareOp get_compareOp() { return m_struct.compareOp; } 4074 void set_compareOp(VkCompareOp inValue) { m_struct.compareOp = inValue; } 4075 float get_minLod() { return m_struct.minLod; } 4076 void set_minLod(float inValue) { m_struct.minLod = inValue; } 4077 float get_maxLod() { return m_struct.maxLod; } 4078 void set_maxLod(float inValue) { m_struct.maxLod = inValue; } 4079 VkBorderColor get_borderColor() { return m_struct.borderColor; } 4080 void set_borderColor(VkBorderColor inValue) { m_struct.borderColor = inValue; } 4081 VkBool32 get_unnormalizedCoordinates() { return m_struct.unnormalizedCoordinates; } 4082 void set_unnormalizedCoordinates(VkBool32 inValue) { m_struct.unnormalizedCoordinates = inValue; } 4083 4084 4085 private: 4086 VkSamplerCreateInfo m_struct; 4087 const VkSamplerCreateInfo* m_origStructAddr; 4088 uint32_t m_indent; 4089 const char m_dummy_prefix; 4090 void display_struct_members(); 4091 4092 }; 4093 4094 4095 //class declaration 4096 class vksemaphorecreateinfo_struct_wrapper 4097 { 4098 public: 4099 vksemaphorecreateinfo_struct_wrapper(); 4100 vksemaphorecreateinfo_struct_wrapper(VkSemaphoreCreateInfo* pInStruct); 4101 vksemaphorecreateinfo_struct_wrapper(const VkSemaphoreCreateInfo* pInStruct); 4102 4103 virtual ~vksemaphorecreateinfo_struct_wrapper(); 4104 4105 void display_txt(); 4106 void display_single_txt(); 4107 void display_full_txt(); 4108 4109 void set_indent(uint32_t indent) { m_indent = indent; } 4110 VkStructureType get_sType() { return m_struct.sType; } 4111 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4112 const void* get_pNext() { return m_struct.pNext; } 4113 VkSemaphoreCreateFlags get_flags() { return m_struct.flags; } 4114 void set_flags(VkSemaphoreCreateFlags inValue) { m_struct.flags = inValue; } 4115 4116 4117 private: 4118 VkSemaphoreCreateInfo m_struct; 4119 const VkSemaphoreCreateInfo* m_origStructAddr; 4120 uint32_t m_indent; 4121 const char m_dummy_prefix; 4122 void display_struct_members(); 4123 4124 }; 4125 4126 4127 //class declaration 4128 class vkshadermodulecreateinfo_struct_wrapper 4129 { 4130 public: 4131 vkshadermodulecreateinfo_struct_wrapper(); 4132 vkshadermodulecreateinfo_struct_wrapper(VkShaderModuleCreateInfo* pInStruct); 4133 vkshadermodulecreateinfo_struct_wrapper(const VkShaderModuleCreateInfo* pInStruct); 4134 4135 virtual ~vkshadermodulecreateinfo_struct_wrapper(); 4136 4137 void display_txt(); 4138 void display_single_txt(); 4139 void display_full_txt(); 4140 4141 void set_indent(uint32_t indent) { m_indent = indent; } 4142 VkStructureType get_sType() { return m_struct.sType; } 4143 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4144 const void* get_pNext() { return m_struct.pNext; } 4145 VkShaderModuleCreateFlags get_flags() { return m_struct.flags; } 4146 void set_flags(VkShaderModuleCreateFlags inValue) { m_struct.flags = inValue; } 4147 size_t get_codeSize() { return m_struct.codeSize; } 4148 void set_codeSize(size_t inValue) { m_struct.codeSize = inValue; } 4149 const uint32_t* get_pCode() { return m_struct.pCode; } 4150 4151 4152 private: 4153 VkShaderModuleCreateInfo m_struct; 4154 const VkShaderModuleCreateInfo* m_origStructAddr; 4155 uint32_t m_indent; 4156 const char m_dummy_prefix; 4157 void display_struct_members(); 4158 4159 }; 4160 4161 4162 //class declaration 4163 class vksparsebuffermemorybindinfo_struct_wrapper 4164 { 4165 public: 4166 vksparsebuffermemorybindinfo_struct_wrapper(); 4167 vksparsebuffermemorybindinfo_struct_wrapper(VkSparseBufferMemoryBindInfo* pInStruct); 4168 vksparsebuffermemorybindinfo_struct_wrapper(const VkSparseBufferMemoryBindInfo* pInStruct); 4169 4170 virtual ~vksparsebuffermemorybindinfo_struct_wrapper(); 4171 4172 void display_txt(); 4173 void display_single_txt(); 4174 void display_full_txt(); 4175 4176 void set_indent(uint32_t indent) { m_indent = indent; } 4177 VkBuffer get_buffer() { return m_struct.buffer; } 4178 void set_buffer(VkBuffer inValue) { m_struct.buffer = inValue; } 4179 uint32_t get_bindCount() { return m_struct.bindCount; } 4180 void set_bindCount(uint32_t inValue) { m_struct.bindCount = inValue; } 4181 4182 4183 private: 4184 VkSparseBufferMemoryBindInfo m_struct; 4185 const VkSparseBufferMemoryBindInfo* m_origStructAddr; 4186 uint32_t m_indent; 4187 const char m_dummy_prefix; 4188 void display_struct_members(); 4189 4190 }; 4191 4192 4193 //class declaration 4194 class vksparseimageformatproperties_struct_wrapper 4195 { 4196 public: 4197 vksparseimageformatproperties_struct_wrapper(); 4198 vksparseimageformatproperties_struct_wrapper(VkSparseImageFormatProperties* pInStruct); 4199 vksparseimageformatproperties_struct_wrapper(const VkSparseImageFormatProperties* pInStruct); 4200 4201 virtual ~vksparseimageformatproperties_struct_wrapper(); 4202 4203 void display_txt(); 4204 void display_single_txt(); 4205 void display_full_txt(); 4206 4207 void set_indent(uint32_t indent) { m_indent = indent; } 4208 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 4209 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 4210 VkExtent3D get_imageGranularity() { return m_struct.imageGranularity; } 4211 void set_imageGranularity(VkExtent3D inValue) { m_struct.imageGranularity = inValue; } 4212 VkSparseImageFormatFlags get_flags() { return m_struct.flags; } 4213 void set_flags(VkSparseImageFormatFlags inValue) { m_struct.flags = inValue; } 4214 4215 4216 private: 4217 VkSparseImageFormatProperties m_struct; 4218 const VkSparseImageFormatProperties* m_origStructAddr; 4219 uint32_t m_indent; 4220 const char m_dummy_prefix; 4221 void display_struct_members(); 4222 4223 }; 4224 4225 4226 //class declaration 4227 class vksparseimagememorybind_struct_wrapper 4228 { 4229 public: 4230 vksparseimagememorybind_struct_wrapper(); 4231 vksparseimagememorybind_struct_wrapper(VkSparseImageMemoryBind* pInStruct); 4232 vksparseimagememorybind_struct_wrapper(const VkSparseImageMemoryBind* pInStruct); 4233 4234 virtual ~vksparseimagememorybind_struct_wrapper(); 4235 4236 void display_txt(); 4237 void display_single_txt(); 4238 void display_full_txt(); 4239 4240 void set_indent(uint32_t indent) { m_indent = indent; } 4241 VkImageSubresource get_subresource() { return m_struct.subresource; } 4242 void set_subresource(VkImageSubresource inValue) { m_struct.subresource = inValue; } 4243 VkOffset3D get_offset() { return m_struct.offset; } 4244 void set_offset(VkOffset3D inValue) { m_struct.offset = inValue; } 4245 VkExtent3D get_extent() { return m_struct.extent; } 4246 void set_extent(VkExtent3D inValue) { m_struct.extent = inValue; } 4247 VkDeviceMemory get_memory() { return m_struct.memory; } 4248 void set_memory(VkDeviceMemory inValue) { m_struct.memory = inValue; } 4249 VkDeviceSize get_memoryOffset() { return m_struct.memoryOffset; } 4250 void set_memoryOffset(VkDeviceSize inValue) { m_struct.memoryOffset = inValue; } 4251 VkSparseMemoryBindFlags get_flags() { return m_struct.flags; } 4252 void set_flags(VkSparseMemoryBindFlags inValue) { m_struct.flags = inValue; } 4253 4254 4255 private: 4256 VkSparseImageMemoryBind m_struct; 4257 const VkSparseImageMemoryBind* m_origStructAddr; 4258 uint32_t m_indent; 4259 const char m_dummy_prefix; 4260 void display_struct_members(); 4261 4262 }; 4263 4264 4265 //class declaration 4266 class vksparseimagememorybindinfo_struct_wrapper 4267 { 4268 public: 4269 vksparseimagememorybindinfo_struct_wrapper(); 4270 vksparseimagememorybindinfo_struct_wrapper(VkSparseImageMemoryBindInfo* pInStruct); 4271 vksparseimagememorybindinfo_struct_wrapper(const VkSparseImageMemoryBindInfo* pInStruct); 4272 4273 virtual ~vksparseimagememorybindinfo_struct_wrapper(); 4274 4275 void display_txt(); 4276 void display_single_txt(); 4277 void display_full_txt(); 4278 4279 void set_indent(uint32_t indent) { m_indent = indent; } 4280 VkImage get_image() { return m_struct.image; } 4281 void set_image(VkImage inValue) { m_struct.image = inValue; } 4282 uint32_t get_bindCount() { return m_struct.bindCount; } 4283 void set_bindCount(uint32_t inValue) { m_struct.bindCount = inValue; } 4284 4285 4286 private: 4287 VkSparseImageMemoryBindInfo m_struct; 4288 const VkSparseImageMemoryBindInfo* m_origStructAddr; 4289 uint32_t m_indent; 4290 const char m_dummy_prefix; 4291 void display_struct_members(); 4292 4293 }; 4294 4295 4296 //class declaration 4297 class vksparseimagememoryrequirements_struct_wrapper 4298 { 4299 public: 4300 vksparseimagememoryrequirements_struct_wrapper(); 4301 vksparseimagememoryrequirements_struct_wrapper(VkSparseImageMemoryRequirements* pInStruct); 4302 vksparseimagememoryrequirements_struct_wrapper(const VkSparseImageMemoryRequirements* pInStruct); 4303 4304 virtual ~vksparseimagememoryrequirements_struct_wrapper(); 4305 4306 void display_txt(); 4307 void display_single_txt(); 4308 void display_full_txt(); 4309 4310 void set_indent(uint32_t indent) { m_indent = indent; } 4311 VkSparseImageFormatProperties get_formatProperties() { return m_struct.formatProperties; } 4312 void set_formatProperties(VkSparseImageFormatProperties inValue) { m_struct.formatProperties = inValue; } 4313 uint32_t get_imageMipTailFirstLod() { return m_struct.imageMipTailFirstLod; } 4314 void set_imageMipTailFirstLod(uint32_t inValue) { m_struct.imageMipTailFirstLod = inValue; } 4315 VkDeviceSize get_imageMipTailSize() { return m_struct.imageMipTailSize; } 4316 void set_imageMipTailSize(VkDeviceSize inValue) { m_struct.imageMipTailSize = inValue; } 4317 VkDeviceSize get_imageMipTailOffset() { return m_struct.imageMipTailOffset; } 4318 void set_imageMipTailOffset(VkDeviceSize inValue) { m_struct.imageMipTailOffset = inValue; } 4319 VkDeviceSize get_imageMipTailStride() { return m_struct.imageMipTailStride; } 4320 void set_imageMipTailStride(VkDeviceSize inValue) { m_struct.imageMipTailStride = inValue; } 4321 4322 4323 private: 4324 VkSparseImageMemoryRequirements m_struct; 4325 const VkSparseImageMemoryRequirements* m_origStructAddr; 4326 uint32_t m_indent; 4327 const char m_dummy_prefix; 4328 void display_struct_members(); 4329 4330 }; 4331 4332 4333 //class declaration 4334 class vksparseimageopaquememorybindinfo_struct_wrapper 4335 { 4336 public: 4337 vksparseimageopaquememorybindinfo_struct_wrapper(); 4338 vksparseimageopaquememorybindinfo_struct_wrapper(VkSparseImageOpaqueMemoryBindInfo* pInStruct); 4339 vksparseimageopaquememorybindinfo_struct_wrapper(const VkSparseImageOpaqueMemoryBindInfo* pInStruct); 4340 4341 virtual ~vksparseimageopaquememorybindinfo_struct_wrapper(); 4342 4343 void display_txt(); 4344 void display_single_txt(); 4345 void display_full_txt(); 4346 4347 void set_indent(uint32_t indent) { m_indent = indent; } 4348 VkImage get_image() { return m_struct.image; } 4349 void set_image(VkImage inValue) { m_struct.image = inValue; } 4350 uint32_t get_bindCount() { return m_struct.bindCount; } 4351 void set_bindCount(uint32_t inValue) { m_struct.bindCount = inValue; } 4352 4353 4354 private: 4355 VkSparseImageOpaqueMemoryBindInfo m_struct; 4356 const VkSparseImageOpaqueMemoryBindInfo* m_origStructAddr; 4357 uint32_t m_indent; 4358 const char m_dummy_prefix; 4359 void display_struct_members(); 4360 4361 }; 4362 4363 4364 //class declaration 4365 class vksparsememorybind_struct_wrapper 4366 { 4367 public: 4368 vksparsememorybind_struct_wrapper(); 4369 vksparsememorybind_struct_wrapper(VkSparseMemoryBind* pInStruct); 4370 vksparsememorybind_struct_wrapper(const VkSparseMemoryBind* pInStruct); 4371 4372 virtual ~vksparsememorybind_struct_wrapper(); 4373 4374 void display_txt(); 4375 void display_single_txt(); 4376 void display_full_txt(); 4377 4378 void set_indent(uint32_t indent) { m_indent = indent; } 4379 VkDeviceSize get_resourceOffset() { return m_struct.resourceOffset; } 4380 void set_resourceOffset(VkDeviceSize inValue) { m_struct.resourceOffset = inValue; } 4381 VkDeviceSize get_size() { return m_struct.size; } 4382 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 4383 VkDeviceMemory get_memory() { return m_struct.memory; } 4384 void set_memory(VkDeviceMemory inValue) { m_struct.memory = inValue; } 4385 VkDeviceSize get_memoryOffset() { return m_struct.memoryOffset; } 4386 void set_memoryOffset(VkDeviceSize inValue) { m_struct.memoryOffset = inValue; } 4387 VkSparseMemoryBindFlags get_flags() { return m_struct.flags; } 4388 void set_flags(VkSparseMemoryBindFlags inValue) { m_struct.flags = inValue; } 4389 4390 4391 private: 4392 VkSparseMemoryBind m_struct; 4393 const VkSparseMemoryBind* m_origStructAddr; 4394 uint32_t m_indent; 4395 const char m_dummy_prefix; 4396 void display_struct_members(); 4397 4398 }; 4399 4400 4401 //class declaration 4402 class vkspecializationinfo_struct_wrapper 4403 { 4404 public: 4405 vkspecializationinfo_struct_wrapper(); 4406 vkspecializationinfo_struct_wrapper(VkSpecializationInfo* pInStruct); 4407 vkspecializationinfo_struct_wrapper(const VkSpecializationInfo* pInStruct); 4408 4409 virtual ~vkspecializationinfo_struct_wrapper(); 4410 4411 void display_txt(); 4412 void display_single_txt(); 4413 void display_full_txt(); 4414 4415 void set_indent(uint32_t indent) { m_indent = indent; } 4416 uint32_t get_mapEntryCount() { return m_struct.mapEntryCount; } 4417 void set_mapEntryCount(uint32_t inValue) { m_struct.mapEntryCount = inValue; } 4418 size_t get_dataSize() { return m_struct.dataSize; } 4419 void set_dataSize(size_t inValue) { m_struct.dataSize = inValue; } 4420 const void* get_pData() { return m_struct.pData; } 4421 4422 4423 private: 4424 VkSpecializationInfo m_struct; 4425 const VkSpecializationInfo* m_origStructAddr; 4426 uint32_t m_indent; 4427 const char m_dummy_prefix; 4428 void display_struct_members(); 4429 4430 }; 4431 4432 4433 //class declaration 4434 class vkspecializationmapentry_struct_wrapper 4435 { 4436 public: 4437 vkspecializationmapentry_struct_wrapper(); 4438 vkspecializationmapentry_struct_wrapper(VkSpecializationMapEntry* pInStruct); 4439 vkspecializationmapentry_struct_wrapper(const VkSpecializationMapEntry* pInStruct); 4440 4441 virtual ~vkspecializationmapentry_struct_wrapper(); 4442 4443 void display_txt(); 4444 void display_single_txt(); 4445 void display_full_txt(); 4446 4447 void set_indent(uint32_t indent) { m_indent = indent; } 4448 uint32_t get_constantID() { return m_struct.constantID; } 4449 void set_constantID(uint32_t inValue) { m_struct.constantID = inValue; } 4450 uint32_t get_offset() { return m_struct.offset; } 4451 void set_offset(uint32_t inValue) { m_struct.offset = inValue; } 4452 size_t get_size() { return m_struct.size; } 4453 void set_size(size_t inValue) { m_struct.size = inValue; } 4454 4455 4456 private: 4457 VkSpecializationMapEntry m_struct; 4458 const VkSpecializationMapEntry* m_origStructAddr; 4459 uint32_t m_indent; 4460 const char m_dummy_prefix; 4461 void display_struct_members(); 4462 4463 }; 4464 4465 4466 //class declaration 4467 class vkstencilopstate_struct_wrapper 4468 { 4469 public: 4470 vkstencilopstate_struct_wrapper(); 4471 vkstencilopstate_struct_wrapper(VkStencilOpState* pInStruct); 4472 vkstencilopstate_struct_wrapper(const VkStencilOpState* pInStruct); 4473 4474 virtual ~vkstencilopstate_struct_wrapper(); 4475 4476 void display_txt(); 4477 void display_single_txt(); 4478 void display_full_txt(); 4479 4480 void set_indent(uint32_t indent) { m_indent = indent; } 4481 VkStencilOp get_failOp() { return m_struct.failOp; } 4482 void set_failOp(VkStencilOp inValue) { m_struct.failOp = inValue; } 4483 VkStencilOp get_passOp() { return m_struct.passOp; } 4484 void set_passOp(VkStencilOp inValue) { m_struct.passOp = inValue; } 4485 VkStencilOp get_depthFailOp() { return m_struct.depthFailOp; } 4486 void set_depthFailOp(VkStencilOp inValue) { m_struct.depthFailOp = inValue; } 4487 VkCompareOp get_compareOp() { return m_struct.compareOp; } 4488 void set_compareOp(VkCompareOp inValue) { m_struct.compareOp = inValue; } 4489 uint32_t get_compareMask() { return m_struct.compareMask; } 4490 void set_compareMask(uint32_t inValue) { m_struct.compareMask = inValue; } 4491 uint32_t get_writeMask() { return m_struct.writeMask; } 4492 void set_writeMask(uint32_t inValue) { m_struct.writeMask = inValue; } 4493 uint32_t get_reference() { return m_struct.reference; } 4494 void set_reference(uint32_t inValue) { m_struct.reference = inValue; } 4495 4496 4497 private: 4498 VkStencilOpState m_struct; 4499 const VkStencilOpState* m_origStructAddr; 4500 uint32_t m_indent; 4501 const char m_dummy_prefix; 4502 void display_struct_members(); 4503 4504 }; 4505 4506 4507 //class declaration 4508 class vksubmitinfo_struct_wrapper 4509 { 4510 public: 4511 vksubmitinfo_struct_wrapper(); 4512 vksubmitinfo_struct_wrapper(VkSubmitInfo* pInStruct); 4513 vksubmitinfo_struct_wrapper(const VkSubmitInfo* pInStruct); 4514 4515 virtual ~vksubmitinfo_struct_wrapper(); 4516 4517 void display_txt(); 4518 void display_single_txt(); 4519 void display_full_txt(); 4520 4521 void set_indent(uint32_t indent) { m_indent = indent; } 4522 VkStructureType get_sType() { return m_struct.sType; } 4523 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4524 const void* get_pNext() { return m_struct.pNext; } 4525 uint32_t get_waitSemaphoreCount() { return m_struct.waitSemaphoreCount; } 4526 void set_waitSemaphoreCount(uint32_t inValue) { m_struct.waitSemaphoreCount = inValue; } 4527 const VkPipelineStageFlags* get_pWaitDstStageMask() { return m_struct.pWaitDstStageMask; } 4528 uint32_t get_commandBufferCount() { return m_struct.commandBufferCount; } 4529 void set_commandBufferCount(uint32_t inValue) { m_struct.commandBufferCount = inValue; } 4530 uint32_t get_signalSemaphoreCount() { return m_struct.signalSemaphoreCount; } 4531 void set_signalSemaphoreCount(uint32_t inValue) { m_struct.signalSemaphoreCount = inValue; } 4532 4533 4534 private: 4535 VkSubmitInfo m_struct; 4536 const VkSubmitInfo* m_origStructAddr; 4537 uint32_t m_indent; 4538 const char m_dummy_prefix; 4539 void display_struct_members(); 4540 4541 }; 4542 4543 4544 //class declaration 4545 class vksubpassdependency_struct_wrapper 4546 { 4547 public: 4548 vksubpassdependency_struct_wrapper(); 4549 vksubpassdependency_struct_wrapper(VkSubpassDependency* pInStruct); 4550 vksubpassdependency_struct_wrapper(const VkSubpassDependency* pInStruct); 4551 4552 virtual ~vksubpassdependency_struct_wrapper(); 4553 4554 void display_txt(); 4555 void display_single_txt(); 4556 void display_full_txt(); 4557 4558 void set_indent(uint32_t indent) { m_indent = indent; } 4559 uint32_t get_srcSubpass() { return m_struct.srcSubpass; } 4560 void set_srcSubpass(uint32_t inValue) { m_struct.srcSubpass = inValue; } 4561 uint32_t get_dstSubpass() { return m_struct.dstSubpass; } 4562 void set_dstSubpass(uint32_t inValue) { m_struct.dstSubpass = inValue; } 4563 VkPipelineStageFlags get_srcStageMask() { return m_struct.srcStageMask; } 4564 void set_srcStageMask(VkPipelineStageFlags inValue) { m_struct.srcStageMask = inValue; } 4565 VkPipelineStageFlags get_dstStageMask() { return m_struct.dstStageMask; } 4566 void set_dstStageMask(VkPipelineStageFlags inValue) { m_struct.dstStageMask = inValue; } 4567 VkAccessFlags get_srcAccessMask() { return m_struct.srcAccessMask; } 4568 void set_srcAccessMask(VkAccessFlags inValue) { m_struct.srcAccessMask = inValue; } 4569 VkAccessFlags get_dstAccessMask() { return m_struct.dstAccessMask; } 4570 void set_dstAccessMask(VkAccessFlags inValue) { m_struct.dstAccessMask = inValue; } 4571 VkDependencyFlags get_dependencyFlags() { return m_struct.dependencyFlags; } 4572 void set_dependencyFlags(VkDependencyFlags inValue) { m_struct.dependencyFlags = inValue; } 4573 4574 4575 private: 4576 VkSubpassDependency m_struct; 4577 const VkSubpassDependency* m_origStructAddr; 4578 uint32_t m_indent; 4579 const char m_dummy_prefix; 4580 void display_struct_members(); 4581 4582 }; 4583 4584 4585 //class declaration 4586 class vksubpassdescription_struct_wrapper 4587 { 4588 public: 4589 vksubpassdescription_struct_wrapper(); 4590 vksubpassdescription_struct_wrapper(VkSubpassDescription* pInStruct); 4591 vksubpassdescription_struct_wrapper(const VkSubpassDescription* pInStruct); 4592 4593 virtual ~vksubpassdescription_struct_wrapper(); 4594 4595 void display_txt(); 4596 void display_single_txt(); 4597 void display_full_txt(); 4598 4599 void set_indent(uint32_t indent) { m_indent = indent; } 4600 VkSubpassDescriptionFlags get_flags() { return m_struct.flags; } 4601 void set_flags(VkSubpassDescriptionFlags inValue) { m_struct.flags = inValue; } 4602 VkPipelineBindPoint get_pipelineBindPoint() { return m_struct.pipelineBindPoint; } 4603 void set_pipelineBindPoint(VkPipelineBindPoint inValue) { m_struct.pipelineBindPoint = inValue; } 4604 uint32_t get_inputAttachmentCount() { return m_struct.inputAttachmentCount; } 4605 void set_inputAttachmentCount(uint32_t inValue) { m_struct.inputAttachmentCount = inValue; } 4606 uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; } 4607 void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; } 4608 const VkAttachmentReference* get_pDepthStencilAttachment() { return m_struct.pDepthStencilAttachment; } 4609 uint32_t get_preserveAttachmentCount() { return m_struct.preserveAttachmentCount; } 4610 void set_preserveAttachmentCount(uint32_t inValue) { m_struct.preserveAttachmentCount = inValue; } 4611 4612 4613 private: 4614 VkSubpassDescription m_struct; 4615 const VkSubpassDescription* m_origStructAddr; 4616 uint32_t m_indent; 4617 const char m_dummy_prefix; 4618 void display_struct_members(); 4619 4620 }; 4621 4622 4623 //class declaration 4624 class vksubresourcelayout_struct_wrapper 4625 { 4626 public: 4627 vksubresourcelayout_struct_wrapper(); 4628 vksubresourcelayout_struct_wrapper(VkSubresourceLayout* pInStruct); 4629 vksubresourcelayout_struct_wrapper(const VkSubresourceLayout* pInStruct); 4630 4631 virtual ~vksubresourcelayout_struct_wrapper(); 4632 4633 void display_txt(); 4634 void display_single_txt(); 4635 void display_full_txt(); 4636 4637 void set_indent(uint32_t indent) { m_indent = indent; } 4638 VkDeviceSize get_offset() { return m_struct.offset; } 4639 void set_offset(VkDeviceSize inValue) { m_struct.offset = inValue; } 4640 VkDeviceSize get_size() { return m_struct.size; } 4641 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 4642 VkDeviceSize get_rowPitch() { return m_struct.rowPitch; } 4643 void set_rowPitch(VkDeviceSize inValue) { m_struct.rowPitch = inValue; } 4644 VkDeviceSize get_arrayPitch() { return m_struct.arrayPitch; } 4645 void set_arrayPitch(VkDeviceSize inValue) { m_struct.arrayPitch = inValue; } 4646 VkDeviceSize get_depthPitch() { return m_struct.depthPitch; } 4647 void set_depthPitch(VkDeviceSize inValue) { m_struct.depthPitch = inValue; } 4648 4649 4650 private: 4651 VkSubresourceLayout m_struct; 4652 const VkSubresourceLayout* m_origStructAddr; 4653 uint32_t m_indent; 4654 const char m_dummy_prefix; 4655 void display_struct_members(); 4656 4657 }; 4658 4659 4660 //class declaration 4661 class vksurfacecapabilitieskhr_struct_wrapper 4662 { 4663 public: 4664 vksurfacecapabilitieskhr_struct_wrapper(); 4665 vksurfacecapabilitieskhr_struct_wrapper(VkSurfaceCapabilitiesKHR* pInStruct); 4666 vksurfacecapabilitieskhr_struct_wrapper(const VkSurfaceCapabilitiesKHR* pInStruct); 4667 4668 virtual ~vksurfacecapabilitieskhr_struct_wrapper(); 4669 4670 void display_txt(); 4671 void display_single_txt(); 4672 void display_full_txt(); 4673 4674 void set_indent(uint32_t indent) { m_indent = indent; } 4675 uint32_t get_minImageCount() { return m_struct.minImageCount; } 4676 void set_minImageCount(uint32_t inValue) { m_struct.minImageCount = inValue; } 4677 uint32_t get_maxImageCount() { return m_struct.maxImageCount; } 4678 void set_maxImageCount(uint32_t inValue) { m_struct.maxImageCount = inValue; } 4679 VkExtent2D get_currentExtent() { return m_struct.currentExtent; } 4680 void set_currentExtent(VkExtent2D inValue) { m_struct.currentExtent = inValue; } 4681 VkExtent2D get_minImageExtent() { return m_struct.minImageExtent; } 4682 void set_minImageExtent(VkExtent2D inValue) { m_struct.minImageExtent = inValue; } 4683 VkExtent2D get_maxImageExtent() { return m_struct.maxImageExtent; } 4684 void set_maxImageExtent(VkExtent2D inValue) { m_struct.maxImageExtent = inValue; } 4685 uint32_t get_maxImageArrayLayers() { return m_struct.maxImageArrayLayers; } 4686 void set_maxImageArrayLayers(uint32_t inValue) { m_struct.maxImageArrayLayers = inValue; } 4687 VkSurfaceTransformFlagsKHR get_supportedTransforms() { return m_struct.supportedTransforms; } 4688 void set_supportedTransforms(VkSurfaceTransformFlagsKHR inValue) { m_struct.supportedTransforms = inValue; } 4689 VkSurfaceTransformFlagBitsKHR get_currentTransform() { return m_struct.currentTransform; } 4690 void set_currentTransform(VkSurfaceTransformFlagBitsKHR inValue) { m_struct.currentTransform = inValue; } 4691 VkCompositeAlphaFlagsKHR get_supportedCompositeAlpha() { return m_struct.supportedCompositeAlpha; } 4692 void set_supportedCompositeAlpha(VkCompositeAlphaFlagsKHR inValue) { m_struct.supportedCompositeAlpha = inValue; } 4693 VkImageUsageFlags get_supportedUsageFlags() { return m_struct.supportedUsageFlags; } 4694 void set_supportedUsageFlags(VkImageUsageFlags inValue) { m_struct.supportedUsageFlags = inValue; } 4695 4696 4697 private: 4698 VkSurfaceCapabilitiesKHR m_struct; 4699 const VkSurfaceCapabilitiesKHR* m_origStructAddr; 4700 uint32_t m_indent; 4701 const char m_dummy_prefix; 4702 void display_struct_members(); 4703 4704 }; 4705 4706 4707 //class declaration 4708 class vksurfaceformatkhr_struct_wrapper 4709 { 4710 public: 4711 vksurfaceformatkhr_struct_wrapper(); 4712 vksurfaceformatkhr_struct_wrapper(VkSurfaceFormatKHR* pInStruct); 4713 vksurfaceformatkhr_struct_wrapper(const VkSurfaceFormatKHR* pInStruct); 4714 4715 virtual ~vksurfaceformatkhr_struct_wrapper(); 4716 4717 void display_txt(); 4718 void display_single_txt(); 4719 void display_full_txt(); 4720 4721 void set_indent(uint32_t indent) { m_indent = indent; } 4722 VkFormat get_format() { return m_struct.format; } 4723 void set_format(VkFormat inValue) { m_struct.format = inValue; } 4724 VkColorSpaceKHR get_colorSpace() { return m_struct.colorSpace; } 4725 void set_colorSpace(VkColorSpaceKHR inValue) { m_struct.colorSpace = inValue; } 4726 4727 4728 private: 4729 VkSurfaceFormatKHR m_struct; 4730 const VkSurfaceFormatKHR* m_origStructAddr; 4731 uint32_t m_indent; 4732 const char m_dummy_prefix; 4733 void display_struct_members(); 4734 4735 }; 4736 4737 4738 //class declaration 4739 class vkswapchaincreateinfokhr_struct_wrapper 4740 { 4741 public: 4742 vkswapchaincreateinfokhr_struct_wrapper(); 4743 vkswapchaincreateinfokhr_struct_wrapper(VkSwapchainCreateInfoKHR* pInStruct); 4744 vkswapchaincreateinfokhr_struct_wrapper(const VkSwapchainCreateInfoKHR* pInStruct); 4745 4746 virtual ~vkswapchaincreateinfokhr_struct_wrapper(); 4747 4748 void display_txt(); 4749 void display_single_txt(); 4750 void display_full_txt(); 4751 4752 void set_indent(uint32_t indent) { m_indent = indent; } 4753 VkStructureType get_sType() { return m_struct.sType; } 4754 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4755 const void* get_pNext() { return m_struct.pNext; } 4756 VkSwapchainCreateFlagsKHR get_flags() { return m_struct.flags; } 4757 void set_flags(VkSwapchainCreateFlagsKHR inValue) { m_struct.flags = inValue; } 4758 VkSurfaceKHR get_surface() { return m_struct.surface; } 4759 void set_surface(VkSurfaceKHR inValue) { m_struct.surface = inValue; } 4760 uint32_t get_minImageCount() { return m_struct.minImageCount; } 4761 void set_minImageCount(uint32_t inValue) { m_struct.minImageCount = inValue; } 4762 VkFormat get_imageFormat() { return m_struct.imageFormat; } 4763 void set_imageFormat(VkFormat inValue) { m_struct.imageFormat = inValue; } 4764 VkColorSpaceKHR get_imageColorSpace() { return m_struct.imageColorSpace; } 4765 void set_imageColorSpace(VkColorSpaceKHR inValue) { m_struct.imageColorSpace = inValue; } 4766 VkExtent2D get_imageExtent() { return m_struct.imageExtent; } 4767 void set_imageExtent(VkExtent2D inValue) { m_struct.imageExtent = inValue; } 4768 uint32_t get_imageArrayLayers() { return m_struct.imageArrayLayers; } 4769 void set_imageArrayLayers(uint32_t inValue) { m_struct.imageArrayLayers = inValue; } 4770 VkImageUsageFlags get_imageUsage() { return m_struct.imageUsage; } 4771 void set_imageUsage(VkImageUsageFlags inValue) { m_struct.imageUsage = inValue; } 4772 VkSharingMode get_imageSharingMode() { return m_struct.imageSharingMode; } 4773 void set_imageSharingMode(VkSharingMode inValue) { m_struct.imageSharingMode = inValue; } 4774 uint32_t get_queueFamilyIndexCount() { return m_struct.queueFamilyIndexCount; } 4775 void set_queueFamilyIndexCount(uint32_t inValue) { m_struct.queueFamilyIndexCount = inValue; } 4776 VkSurfaceTransformFlagBitsKHR get_preTransform() { return m_struct.preTransform; } 4777 void set_preTransform(VkSurfaceTransformFlagBitsKHR inValue) { m_struct.preTransform = inValue; } 4778 VkCompositeAlphaFlagBitsKHR get_compositeAlpha() { return m_struct.compositeAlpha; } 4779 void set_compositeAlpha(VkCompositeAlphaFlagBitsKHR inValue) { m_struct.compositeAlpha = inValue; } 4780 VkPresentModeKHR get_presentMode() { return m_struct.presentMode; } 4781 void set_presentMode(VkPresentModeKHR inValue) { m_struct.presentMode = inValue; } 4782 VkBool32 get_clipped() { return m_struct.clipped; } 4783 void set_clipped(VkBool32 inValue) { m_struct.clipped = inValue; } 4784 VkSwapchainKHR get_oldSwapchain() { return m_struct.oldSwapchain; } 4785 void set_oldSwapchain(VkSwapchainKHR inValue) { m_struct.oldSwapchain = inValue; } 4786 4787 4788 private: 4789 VkSwapchainCreateInfoKHR m_struct; 4790 const VkSwapchainCreateInfoKHR* m_origStructAddr; 4791 uint32_t m_indent; 4792 const char m_dummy_prefix; 4793 void display_struct_members(); 4794 4795 }; 4796 4797 4798 //class declaration 4799 class vkvertexinputattributedescription_struct_wrapper 4800 { 4801 public: 4802 vkvertexinputattributedescription_struct_wrapper(); 4803 vkvertexinputattributedescription_struct_wrapper(VkVertexInputAttributeDescription* pInStruct); 4804 vkvertexinputattributedescription_struct_wrapper(const VkVertexInputAttributeDescription* pInStruct); 4805 4806 virtual ~vkvertexinputattributedescription_struct_wrapper(); 4807 4808 void display_txt(); 4809 void display_single_txt(); 4810 void display_full_txt(); 4811 4812 void set_indent(uint32_t indent) { m_indent = indent; } 4813 uint32_t get_location() { return m_struct.location; } 4814 void set_location(uint32_t inValue) { m_struct.location = inValue; } 4815 uint32_t get_binding() { return m_struct.binding; } 4816 void set_binding(uint32_t inValue) { m_struct.binding = inValue; } 4817 VkFormat get_format() { return m_struct.format; } 4818 void set_format(VkFormat inValue) { m_struct.format = inValue; } 4819 uint32_t get_offset() { return m_struct.offset; } 4820 void set_offset(uint32_t inValue) { m_struct.offset = inValue; } 4821 4822 4823 private: 4824 VkVertexInputAttributeDescription m_struct; 4825 const VkVertexInputAttributeDescription* m_origStructAddr; 4826 uint32_t m_indent; 4827 const char m_dummy_prefix; 4828 void display_struct_members(); 4829 4830 }; 4831 4832 4833 //class declaration 4834 class vkvertexinputbindingdescription_struct_wrapper 4835 { 4836 public: 4837 vkvertexinputbindingdescription_struct_wrapper(); 4838 vkvertexinputbindingdescription_struct_wrapper(VkVertexInputBindingDescription* pInStruct); 4839 vkvertexinputbindingdescription_struct_wrapper(const VkVertexInputBindingDescription* pInStruct); 4840 4841 virtual ~vkvertexinputbindingdescription_struct_wrapper(); 4842 4843 void display_txt(); 4844 void display_single_txt(); 4845 void display_full_txt(); 4846 4847 void set_indent(uint32_t indent) { m_indent = indent; } 4848 uint32_t get_binding() { return m_struct.binding; } 4849 void set_binding(uint32_t inValue) { m_struct.binding = inValue; } 4850 uint32_t get_stride() { return m_struct.stride; } 4851 void set_stride(uint32_t inValue) { m_struct.stride = inValue; } 4852 VkVertexInputRate get_inputRate() { return m_struct.inputRate; } 4853 void set_inputRate(VkVertexInputRate inValue) { m_struct.inputRate = inValue; } 4854 4855 4856 private: 4857 VkVertexInputBindingDescription m_struct; 4858 const VkVertexInputBindingDescription* m_origStructAddr; 4859 uint32_t m_indent; 4860 const char m_dummy_prefix; 4861 void display_struct_members(); 4862 4863 }; 4864 4865 4866 //class declaration 4867 class vkviewport_struct_wrapper 4868 { 4869 public: 4870 vkviewport_struct_wrapper(); 4871 vkviewport_struct_wrapper(VkViewport* pInStruct); 4872 vkviewport_struct_wrapper(const VkViewport* pInStruct); 4873 4874 virtual ~vkviewport_struct_wrapper(); 4875 4876 void display_txt(); 4877 void display_single_txt(); 4878 void display_full_txt(); 4879 4880 void set_indent(uint32_t indent) { m_indent = indent; } 4881 float get_x() { return m_struct.x; } 4882 void set_x(float inValue) { m_struct.x = inValue; } 4883 float get_y() { return m_struct.y; } 4884 void set_y(float inValue) { m_struct.y = inValue; } 4885 float get_width() { return m_struct.width; } 4886 void set_width(float inValue) { m_struct.width = inValue; } 4887 float get_height() { return m_struct.height; } 4888 void set_height(float inValue) { m_struct.height = inValue; } 4889 float get_minDepth() { return m_struct.minDepth; } 4890 void set_minDepth(float inValue) { m_struct.minDepth = inValue; } 4891 float get_maxDepth() { return m_struct.maxDepth; } 4892 void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; } 4893 4894 4895 private: 4896 VkViewport m_struct; 4897 const VkViewport* m_origStructAddr; 4898 uint32_t m_indent; 4899 const char m_dummy_prefix; 4900 void display_struct_members(); 4901 4902 }; 4903 4904 4905 //class declaration 4906 class vkwaylandsurfacecreateinfokhr_struct_wrapper 4907 { 4908 public: 4909 vkwaylandsurfacecreateinfokhr_struct_wrapper(); 4910 vkwaylandsurfacecreateinfokhr_struct_wrapper(VkWaylandSurfaceCreateInfoKHR* pInStruct); 4911 vkwaylandsurfacecreateinfokhr_struct_wrapper(const VkWaylandSurfaceCreateInfoKHR* pInStruct); 4912 4913 virtual ~vkwaylandsurfacecreateinfokhr_struct_wrapper(); 4914 4915 void display_txt(); 4916 void display_single_txt(); 4917 void display_full_txt(); 4918 4919 void set_indent(uint32_t indent) { m_indent = indent; } 4920 VkStructureType get_sType() { return m_struct.sType; } 4921 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4922 const void* get_pNext() { return m_struct.pNext; } 4923 VkWaylandSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 4924 void set_flags(VkWaylandSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 4925 struct wl_display* get_display() { return m_struct.display; } 4926 void set_display(struct wl_display* inValue) { m_struct.display = inValue; } 4927 struct wl_surface* get_surface() { return m_struct.surface; } 4928 void set_surface(struct wl_surface* inValue) { m_struct.surface = inValue; } 4929 4930 4931 private: 4932 VkWaylandSurfaceCreateInfoKHR m_struct; 4933 const VkWaylandSurfaceCreateInfoKHR* m_origStructAddr; 4934 uint32_t m_indent; 4935 const char m_dummy_prefix; 4936 void display_struct_members(); 4937 4938 }; 4939 4940 4941 //class declaration 4942 class vkwin32surfacecreateinfokhr_struct_wrapper 4943 { 4944 public: 4945 vkwin32surfacecreateinfokhr_struct_wrapper(); 4946 vkwin32surfacecreateinfokhr_struct_wrapper(VkWin32SurfaceCreateInfoKHR* pInStruct); 4947 vkwin32surfacecreateinfokhr_struct_wrapper(const VkWin32SurfaceCreateInfoKHR* pInStruct); 4948 4949 virtual ~vkwin32surfacecreateinfokhr_struct_wrapper(); 4950 4951 void display_txt(); 4952 void display_single_txt(); 4953 void display_full_txt(); 4954 4955 void set_indent(uint32_t indent) { m_indent = indent; } 4956 VkStructureType get_sType() { return m_struct.sType; } 4957 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4958 const void* get_pNext() { return m_struct.pNext; } 4959 VkWin32SurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 4960 void set_flags(VkWin32SurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 4961 HINSTANCE get_hinstance() { return m_struct.hinstance; } 4962 void set_hinstance(HINSTANCE inValue) { m_struct.hinstance = inValue; } 4963 HWND get_hwnd() { return m_struct.hwnd; } 4964 void set_hwnd(HWND inValue) { m_struct.hwnd = inValue; } 4965 4966 4967 private: 4968 VkWin32SurfaceCreateInfoKHR m_struct; 4969 const VkWin32SurfaceCreateInfoKHR* m_origStructAddr; 4970 uint32_t m_indent; 4971 const char m_dummy_prefix; 4972 void display_struct_members(); 4973 4974 }; 4975 4976 4977 //class declaration 4978 class vkwritedescriptorset_struct_wrapper 4979 { 4980 public: 4981 vkwritedescriptorset_struct_wrapper(); 4982 vkwritedescriptorset_struct_wrapper(VkWriteDescriptorSet* pInStruct); 4983 vkwritedescriptorset_struct_wrapper(const VkWriteDescriptorSet* pInStruct); 4984 4985 virtual ~vkwritedescriptorset_struct_wrapper(); 4986 4987 void display_txt(); 4988 void display_single_txt(); 4989 void display_full_txt(); 4990 4991 void set_indent(uint32_t indent) { m_indent = indent; } 4992 VkStructureType get_sType() { return m_struct.sType; } 4993 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4994 const void* get_pNext() { return m_struct.pNext; } 4995 VkDescriptorSet get_dstSet() { return m_struct.dstSet; } 4996 void set_dstSet(VkDescriptorSet inValue) { m_struct.dstSet = inValue; } 4997 uint32_t get_dstBinding() { return m_struct.dstBinding; } 4998 void set_dstBinding(uint32_t inValue) { m_struct.dstBinding = inValue; } 4999 uint32_t get_dstArrayElement() { return m_struct.dstArrayElement; } 5000 void set_dstArrayElement(uint32_t inValue) { m_struct.dstArrayElement = inValue; } 5001 uint32_t get_descriptorCount() { return m_struct.descriptorCount; } 5002 void set_descriptorCount(uint32_t inValue) { m_struct.descriptorCount = inValue; } 5003 VkDescriptorType get_descriptorType() { return m_struct.descriptorType; } 5004 void set_descriptorType(VkDescriptorType inValue) { m_struct.descriptorType = inValue; } 5005 5006 5007 private: 5008 VkWriteDescriptorSet m_struct; 5009 const VkWriteDescriptorSet* m_origStructAddr; 5010 uint32_t m_indent; 5011 const char m_dummy_prefix; 5012 void display_struct_members(); 5013 5014 }; 5015 5016 5017 //class declaration 5018 class vkxcbsurfacecreateinfokhr_struct_wrapper 5019 { 5020 public: 5021 vkxcbsurfacecreateinfokhr_struct_wrapper(); 5022 vkxcbsurfacecreateinfokhr_struct_wrapper(VkXcbSurfaceCreateInfoKHR* pInStruct); 5023 vkxcbsurfacecreateinfokhr_struct_wrapper(const VkXcbSurfaceCreateInfoKHR* pInStruct); 5024 5025 virtual ~vkxcbsurfacecreateinfokhr_struct_wrapper(); 5026 5027 void display_txt(); 5028 void display_single_txt(); 5029 void display_full_txt(); 5030 5031 void set_indent(uint32_t indent) { m_indent = indent; } 5032 VkStructureType get_sType() { return m_struct.sType; } 5033 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5034 const void* get_pNext() { return m_struct.pNext; } 5035 VkXcbSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 5036 void set_flags(VkXcbSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 5037 xcb_connection_t* get_connection() { return m_struct.connection; } 5038 void set_connection(xcb_connection_t* inValue) { m_struct.connection = inValue; } 5039 xcb_window_t get_window() { return m_struct.window; } 5040 void set_window(xcb_window_t inValue) { m_struct.window = inValue; } 5041 5042 5043 private: 5044 VkXcbSurfaceCreateInfoKHR m_struct; 5045 const VkXcbSurfaceCreateInfoKHR* m_origStructAddr; 5046 uint32_t m_indent; 5047 const char m_dummy_prefix; 5048 void display_struct_members(); 5049 5050 }; 5051 5052 5053 //class declaration 5054 class vkxlibsurfacecreateinfokhr_struct_wrapper 5055 { 5056 public: 5057 vkxlibsurfacecreateinfokhr_struct_wrapper(); 5058 vkxlibsurfacecreateinfokhr_struct_wrapper(VkXlibSurfaceCreateInfoKHR* pInStruct); 5059 vkxlibsurfacecreateinfokhr_struct_wrapper(const VkXlibSurfaceCreateInfoKHR* pInStruct); 5060 5061 virtual ~vkxlibsurfacecreateinfokhr_struct_wrapper(); 5062 5063 void display_txt(); 5064 void display_single_txt(); 5065 void display_full_txt(); 5066 5067 void set_indent(uint32_t indent) { m_indent = indent; } 5068 VkStructureType get_sType() { return m_struct.sType; } 5069 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5070 const void* get_pNext() { return m_struct.pNext; } 5071 VkXlibSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 5072 void set_flags(VkXlibSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 5073 Display* get_dpy() { return m_struct.dpy; } 5074 void set_dpy(Display* inValue) { m_struct.dpy = inValue; } 5075 Window get_window() { return m_struct.window; } 5076 void set_window(Window inValue) { m_struct.window = inValue; } 5077 5078 5079 private: 5080 VkXlibSurfaceCreateInfoKHR m_struct; 5081 const VkXlibSurfaceCreateInfoKHR* m_origStructAddr; 5082 uint32_t m_indent; 5083 const char m_dummy_prefix; 5084 void display_struct_members(); 5085 5086 }; 5087 5088 //any footer info for class 5089
