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 vkdedicatedallocationbuffercreateinfonv_struct_wrapper 1019 { 1020 public: 1021 vkdedicatedallocationbuffercreateinfonv_struct_wrapper(); 1022 vkdedicatedallocationbuffercreateinfonv_struct_wrapper(VkDedicatedAllocationBufferCreateInfoNV* pInStruct); 1023 vkdedicatedallocationbuffercreateinfonv_struct_wrapper(const VkDedicatedAllocationBufferCreateInfoNV* pInStruct); 1024 1025 virtual ~vkdedicatedallocationbuffercreateinfonv_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 VkStructureType get_sType() { return m_struct.sType; } 1033 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1034 const void* get_pNext() { return m_struct.pNext; } 1035 VkBool32 get_dedicatedAllocation() { return m_struct.dedicatedAllocation; } 1036 void set_dedicatedAllocation(VkBool32 inValue) { m_struct.dedicatedAllocation = inValue; } 1037 1038 1039 private: 1040 VkDedicatedAllocationBufferCreateInfoNV m_struct; 1041 const VkDedicatedAllocationBufferCreateInfoNV* m_origStructAddr; 1042 uint32_t m_indent; 1043 const char m_dummy_prefix; 1044 void display_struct_members(); 1045 1046 }; 1047 1048 1049 //class declaration 1050 class vkdedicatedallocationimagecreateinfonv_struct_wrapper 1051 { 1052 public: 1053 vkdedicatedallocationimagecreateinfonv_struct_wrapper(); 1054 vkdedicatedallocationimagecreateinfonv_struct_wrapper(VkDedicatedAllocationImageCreateInfoNV* pInStruct); 1055 vkdedicatedallocationimagecreateinfonv_struct_wrapper(const VkDedicatedAllocationImageCreateInfoNV* pInStruct); 1056 1057 virtual ~vkdedicatedallocationimagecreateinfonv_struct_wrapper(); 1058 1059 void display_txt(); 1060 void display_single_txt(); 1061 void display_full_txt(); 1062 1063 void set_indent(uint32_t indent) { m_indent = indent; } 1064 VkStructureType get_sType() { return m_struct.sType; } 1065 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1066 const void* get_pNext() { return m_struct.pNext; } 1067 VkBool32 get_dedicatedAllocation() { return m_struct.dedicatedAllocation; } 1068 void set_dedicatedAllocation(VkBool32 inValue) { m_struct.dedicatedAllocation = inValue; } 1069 1070 1071 private: 1072 VkDedicatedAllocationImageCreateInfoNV m_struct; 1073 const VkDedicatedAllocationImageCreateInfoNV* m_origStructAddr; 1074 uint32_t m_indent; 1075 const char m_dummy_prefix; 1076 void display_struct_members(); 1077 1078 }; 1079 1080 1081 //class declaration 1082 class vkdedicatedallocationmemoryallocateinfonv_struct_wrapper 1083 { 1084 public: 1085 vkdedicatedallocationmemoryallocateinfonv_struct_wrapper(); 1086 vkdedicatedallocationmemoryallocateinfonv_struct_wrapper(VkDedicatedAllocationMemoryAllocateInfoNV* pInStruct); 1087 vkdedicatedallocationmemoryallocateinfonv_struct_wrapper(const VkDedicatedAllocationMemoryAllocateInfoNV* pInStruct); 1088 1089 virtual ~vkdedicatedallocationmemoryallocateinfonv_struct_wrapper(); 1090 1091 void display_txt(); 1092 void display_single_txt(); 1093 void display_full_txt(); 1094 1095 void set_indent(uint32_t indent) { m_indent = indent; } 1096 VkStructureType get_sType() { return m_struct.sType; } 1097 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1098 const void* get_pNext() { return m_struct.pNext; } 1099 VkImage get_image() { return m_struct.image; } 1100 void set_image(VkImage inValue) { m_struct.image = inValue; } 1101 VkBuffer get_buffer() { return m_struct.buffer; } 1102 void set_buffer(VkBuffer inValue) { m_struct.buffer = inValue; } 1103 1104 1105 private: 1106 VkDedicatedAllocationMemoryAllocateInfoNV m_struct; 1107 const VkDedicatedAllocationMemoryAllocateInfoNV* m_origStructAddr; 1108 uint32_t m_indent; 1109 const char m_dummy_prefix; 1110 void display_struct_members(); 1111 1112 }; 1113 1114 1115 //class declaration 1116 class vkdescriptorbufferinfo_struct_wrapper 1117 { 1118 public: 1119 vkdescriptorbufferinfo_struct_wrapper(); 1120 vkdescriptorbufferinfo_struct_wrapper(VkDescriptorBufferInfo* pInStruct); 1121 vkdescriptorbufferinfo_struct_wrapper(const VkDescriptorBufferInfo* pInStruct); 1122 1123 virtual ~vkdescriptorbufferinfo_struct_wrapper(); 1124 1125 void display_txt(); 1126 void display_single_txt(); 1127 void display_full_txt(); 1128 1129 void set_indent(uint32_t indent) { m_indent = indent; } 1130 VkBuffer get_buffer() { return m_struct.buffer; } 1131 void set_buffer(VkBuffer inValue) { m_struct.buffer = inValue; } 1132 VkDeviceSize get_offset() { return m_struct.offset; } 1133 void set_offset(VkDeviceSize inValue) { m_struct.offset = inValue; } 1134 VkDeviceSize get_range() { return m_struct.range; } 1135 void set_range(VkDeviceSize inValue) { m_struct.range = inValue; } 1136 1137 1138 private: 1139 VkDescriptorBufferInfo m_struct; 1140 const VkDescriptorBufferInfo* m_origStructAddr; 1141 uint32_t m_indent; 1142 const char m_dummy_prefix; 1143 void display_struct_members(); 1144 1145 }; 1146 1147 1148 //class declaration 1149 class vkdescriptorimageinfo_struct_wrapper 1150 { 1151 public: 1152 vkdescriptorimageinfo_struct_wrapper(); 1153 vkdescriptorimageinfo_struct_wrapper(VkDescriptorImageInfo* pInStruct); 1154 vkdescriptorimageinfo_struct_wrapper(const VkDescriptorImageInfo* pInStruct); 1155 1156 virtual ~vkdescriptorimageinfo_struct_wrapper(); 1157 1158 void display_txt(); 1159 void display_single_txt(); 1160 void display_full_txt(); 1161 1162 void set_indent(uint32_t indent) { m_indent = indent; } 1163 VkSampler get_sampler() { return m_struct.sampler; } 1164 void set_sampler(VkSampler inValue) { m_struct.sampler = inValue; } 1165 VkImageView get_imageView() { return m_struct.imageView; } 1166 void set_imageView(VkImageView inValue) { m_struct.imageView = inValue; } 1167 VkImageLayout get_imageLayout() { return m_struct.imageLayout; } 1168 void set_imageLayout(VkImageLayout inValue) { m_struct.imageLayout = inValue; } 1169 1170 1171 private: 1172 VkDescriptorImageInfo m_struct; 1173 const VkDescriptorImageInfo* m_origStructAddr; 1174 uint32_t m_indent; 1175 const char m_dummy_prefix; 1176 void display_struct_members(); 1177 1178 }; 1179 1180 1181 //class declaration 1182 class vkdescriptorpoolcreateinfo_struct_wrapper 1183 { 1184 public: 1185 vkdescriptorpoolcreateinfo_struct_wrapper(); 1186 vkdescriptorpoolcreateinfo_struct_wrapper(VkDescriptorPoolCreateInfo* pInStruct); 1187 vkdescriptorpoolcreateinfo_struct_wrapper(const VkDescriptorPoolCreateInfo* pInStruct); 1188 1189 virtual ~vkdescriptorpoolcreateinfo_struct_wrapper(); 1190 1191 void display_txt(); 1192 void display_single_txt(); 1193 void display_full_txt(); 1194 1195 void set_indent(uint32_t indent) { m_indent = indent; } 1196 VkStructureType get_sType() { return m_struct.sType; } 1197 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1198 const void* get_pNext() { return m_struct.pNext; } 1199 VkDescriptorPoolCreateFlags get_flags() { return m_struct.flags; } 1200 void set_flags(VkDescriptorPoolCreateFlags inValue) { m_struct.flags = inValue; } 1201 uint32_t get_maxSets() { return m_struct.maxSets; } 1202 void set_maxSets(uint32_t inValue) { m_struct.maxSets = inValue; } 1203 uint32_t get_poolSizeCount() { return m_struct.poolSizeCount; } 1204 void set_poolSizeCount(uint32_t inValue) { m_struct.poolSizeCount = inValue; } 1205 1206 1207 private: 1208 VkDescriptorPoolCreateInfo m_struct; 1209 const VkDescriptorPoolCreateInfo* m_origStructAddr; 1210 uint32_t m_indent; 1211 const char m_dummy_prefix; 1212 void display_struct_members(); 1213 1214 }; 1215 1216 1217 //class declaration 1218 class vkdescriptorpoolsize_struct_wrapper 1219 { 1220 public: 1221 vkdescriptorpoolsize_struct_wrapper(); 1222 vkdescriptorpoolsize_struct_wrapper(VkDescriptorPoolSize* pInStruct); 1223 vkdescriptorpoolsize_struct_wrapper(const VkDescriptorPoolSize* pInStruct); 1224 1225 virtual ~vkdescriptorpoolsize_struct_wrapper(); 1226 1227 void display_txt(); 1228 void display_single_txt(); 1229 void display_full_txt(); 1230 1231 void set_indent(uint32_t indent) { m_indent = indent; } 1232 VkDescriptorType get_type() { return m_struct.type; } 1233 void set_type(VkDescriptorType inValue) { m_struct.type = inValue; } 1234 uint32_t get_descriptorCount() { return m_struct.descriptorCount; } 1235 void set_descriptorCount(uint32_t inValue) { m_struct.descriptorCount = inValue; } 1236 1237 1238 private: 1239 VkDescriptorPoolSize m_struct; 1240 const VkDescriptorPoolSize* m_origStructAddr; 1241 uint32_t m_indent; 1242 const char m_dummy_prefix; 1243 void display_struct_members(); 1244 1245 }; 1246 1247 1248 //class declaration 1249 class vkdescriptorsetallocateinfo_struct_wrapper 1250 { 1251 public: 1252 vkdescriptorsetallocateinfo_struct_wrapper(); 1253 vkdescriptorsetallocateinfo_struct_wrapper(VkDescriptorSetAllocateInfo* pInStruct); 1254 vkdescriptorsetallocateinfo_struct_wrapper(const VkDescriptorSetAllocateInfo* pInStruct); 1255 1256 virtual ~vkdescriptorsetallocateinfo_struct_wrapper(); 1257 1258 void display_txt(); 1259 void display_single_txt(); 1260 void display_full_txt(); 1261 1262 void set_indent(uint32_t indent) { m_indent = indent; } 1263 VkStructureType get_sType() { return m_struct.sType; } 1264 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1265 const void* get_pNext() { return m_struct.pNext; } 1266 VkDescriptorPool get_descriptorPool() { return m_struct.descriptorPool; } 1267 void set_descriptorPool(VkDescriptorPool inValue) { m_struct.descriptorPool = inValue; } 1268 uint32_t get_descriptorSetCount() { return m_struct.descriptorSetCount; } 1269 void set_descriptorSetCount(uint32_t inValue) { m_struct.descriptorSetCount = inValue; } 1270 1271 1272 private: 1273 VkDescriptorSetAllocateInfo m_struct; 1274 const VkDescriptorSetAllocateInfo* m_origStructAddr; 1275 uint32_t m_indent; 1276 const char m_dummy_prefix; 1277 void display_struct_members(); 1278 1279 }; 1280 1281 1282 //class declaration 1283 class vkdescriptorsetlayoutbinding_struct_wrapper 1284 { 1285 public: 1286 vkdescriptorsetlayoutbinding_struct_wrapper(); 1287 vkdescriptorsetlayoutbinding_struct_wrapper(VkDescriptorSetLayoutBinding* pInStruct); 1288 vkdescriptorsetlayoutbinding_struct_wrapper(const VkDescriptorSetLayoutBinding* pInStruct); 1289 1290 virtual ~vkdescriptorsetlayoutbinding_struct_wrapper(); 1291 1292 void display_txt(); 1293 void display_single_txt(); 1294 void display_full_txt(); 1295 1296 void set_indent(uint32_t indent) { m_indent = indent; } 1297 uint32_t get_binding() { return m_struct.binding; } 1298 void set_binding(uint32_t inValue) { m_struct.binding = inValue; } 1299 VkDescriptorType get_descriptorType() { return m_struct.descriptorType; } 1300 void set_descriptorType(VkDescriptorType inValue) { m_struct.descriptorType = inValue; } 1301 uint32_t get_descriptorCount() { return m_struct.descriptorCount; } 1302 void set_descriptorCount(uint32_t inValue) { m_struct.descriptorCount = inValue; } 1303 VkShaderStageFlags get_stageFlags() { return m_struct.stageFlags; } 1304 void set_stageFlags(VkShaderStageFlags inValue) { m_struct.stageFlags = inValue; } 1305 1306 1307 private: 1308 VkDescriptorSetLayoutBinding m_struct; 1309 const VkDescriptorSetLayoutBinding* m_origStructAddr; 1310 uint32_t m_indent; 1311 const char m_dummy_prefix; 1312 void display_struct_members(); 1313 1314 }; 1315 1316 1317 //class declaration 1318 class vkdescriptorsetlayoutcreateinfo_struct_wrapper 1319 { 1320 public: 1321 vkdescriptorsetlayoutcreateinfo_struct_wrapper(); 1322 vkdescriptorsetlayoutcreateinfo_struct_wrapper(VkDescriptorSetLayoutCreateInfo* pInStruct); 1323 vkdescriptorsetlayoutcreateinfo_struct_wrapper(const VkDescriptorSetLayoutCreateInfo* pInStruct); 1324 1325 virtual ~vkdescriptorsetlayoutcreateinfo_struct_wrapper(); 1326 1327 void display_txt(); 1328 void display_single_txt(); 1329 void display_full_txt(); 1330 1331 void set_indent(uint32_t indent) { m_indent = indent; } 1332 VkStructureType get_sType() { return m_struct.sType; } 1333 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1334 const void* get_pNext() { return m_struct.pNext; } 1335 VkDescriptorSetLayoutCreateFlags get_flags() { return m_struct.flags; } 1336 void set_flags(VkDescriptorSetLayoutCreateFlags inValue) { m_struct.flags = inValue; } 1337 uint32_t get_bindingCount() { return m_struct.bindingCount; } 1338 void set_bindingCount(uint32_t inValue) { m_struct.bindingCount = inValue; } 1339 1340 1341 private: 1342 VkDescriptorSetLayoutCreateInfo m_struct; 1343 const VkDescriptorSetLayoutCreateInfo* m_origStructAddr; 1344 uint32_t m_indent; 1345 const char m_dummy_prefix; 1346 void display_struct_members(); 1347 1348 }; 1349 1350 1351 //class declaration 1352 class vkdevicecreateinfo_struct_wrapper 1353 { 1354 public: 1355 vkdevicecreateinfo_struct_wrapper(); 1356 vkdevicecreateinfo_struct_wrapper(VkDeviceCreateInfo* pInStruct); 1357 vkdevicecreateinfo_struct_wrapper(const VkDeviceCreateInfo* pInStruct); 1358 1359 virtual ~vkdevicecreateinfo_struct_wrapper(); 1360 1361 void display_txt(); 1362 void display_single_txt(); 1363 void display_full_txt(); 1364 1365 void set_indent(uint32_t indent) { m_indent = indent; } 1366 VkStructureType get_sType() { return m_struct.sType; } 1367 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1368 const void* get_pNext() { return m_struct.pNext; } 1369 VkDeviceCreateFlags get_flags() { return m_struct.flags; } 1370 void set_flags(VkDeviceCreateFlags inValue) { m_struct.flags = inValue; } 1371 uint32_t get_queueCreateInfoCount() { return m_struct.queueCreateInfoCount; } 1372 void set_queueCreateInfoCount(uint32_t inValue) { m_struct.queueCreateInfoCount = inValue; } 1373 uint32_t get_enabledLayerCount() { return m_struct.enabledLayerCount; } 1374 void set_enabledLayerCount(uint32_t inValue) { m_struct.enabledLayerCount = inValue; } 1375 uint32_t get_enabledExtensionCount() { return m_struct.enabledExtensionCount; } 1376 void set_enabledExtensionCount(uint32_t inValue) { m_struct.enabledExtensionCount = inValue; } 1377 const VkPhysicalDeviceFeatures* get_pEnabledFeatures() { return m_struct.pEnabledFeatures; } 1378 1379 1380 private: 1381 VkDeviceCreateInfo m_struct; 1382 const VkDeviceCreateInfo* m_origStructAddr; 1383 uint32_t m_indent; 1384 const char m_dummy_prefix; 1385 void display_struct_members(); 1386 1387 }; 1388 1389 1390 //class declaration 1391 class vkdevicequeuecreateinfo_struct_wrapper 1392 { 1393 public: 1394 vkdevicequeuecreateinfo_struct_wrapper(); 1395 vkdevicequeuecreateinfo_struct_wrapper(VkDeviceQueueCreateInfo* pInStruct); 1396 vkdevicequeuecreateinfo_struct_wrapper(const VkDeviceQueueCreateInfo* pInStruct); 1397 1398 virtual ~vkdevicequeuecreateinfo_struct_wrapper(); 1399 1400 void display_txt(); 1401 void display_single_txt(); 1402 void display_full_txt(); 1403 1404 void set_indent(uint32_t indent) { m_indent = indent; } 1405 VkStructureType get_sType() { return m_struct.sType; } 1406 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1407 const void* get_pNext() { return m_struct.pNext; } 1408 VkDeviceQueueCreateFlags get_flags() { return m_struct.flags; } 1409 void set_flags(VkDeviceQueueCreateFlags inValue) { m_struct.flags = inValue; } 1410 uint32_t get_queueFamilyIndex() { return m_struct.queueFamilyIndex; } 1411 void set_queueFamilyIndex(uint32_t inValue) { m_struct.queueFamilyIndex = inValue; } 1412 uint32_t get_queueCount() { return m_struct.queueCount; } 1413 void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; } 1414 1415 1416 private: 1417 VkDeviceQueueCreateInfo m_struct; 1418 const VkDeviceQueueCreateInfo* 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 vkdispatchindirectcommand_struct_wrapper 1428 { 1429 public: 1430 vkdispatchindirectcommand_struct_wrapper(); 1431 vkdispatchindirectcommand_struct_wrapper(VkDispatchIndirectCommand* pInStruct); 1432 vkdispatchindirectcommand_struct_wrapper(const VkDispatchIndirectCommand* pInStruct); 1433 1434 virtual ~vkdispatchindirectcommand_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 uint32_t get_x() { return m_struct.x; } 1442 void set_x(uint32_t inValue) { m_struct.x = inValue; } 1443 uint32_t get_y() { return m_struct.y; } 1444 void set_y(uint32_t inValue) { m_struct.y = inValue; } 1445 uint32_t get_z() { return m_struct.z; } 1446 void set_z(uint32_t inValue) { m_struct.z = inValue; } 1447 1448 1449 private: 1450 VkDispatchIndirectCommand m_struct; 1451 const VkDispatchIndirectCommand* m_origStructAddr; 1452 uint32_t m_indent; 1453 const char m_dummy_prefix; 1454 void display_struct_members(); 1455 1456 }; 1457 1458 1459 //class declaration 1460 class vkdisplaymodecreateinfokhr_struct_wrapper 1461 { 1462 public: 1463 vkdisplaymodecreateinfokhr_struct_wrapper(); 1464 vkdisplaymodecreateinfokhr_struct_wrapper(VkDisplayModeCreateInfoKHR* pInStruct); 1465 vkdisplaymodecreateinfokhr_struct_wrapper(const VkDisplayModeCreateInfoKHR* pInStruct); 1466 1467 virtual ~vkdisplaymodecreateinfokhr_struct_wrapper(); 1468 1469 void display_txt(); 1470 void display_single_txt(); 1471 void display_full_txt(); 1472 1473 void set_indent(uint32_t indent) { m_indent = indent; } 1474 VkStructureType get_sType() { return m_struct.sType; } 1475 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1476 const void* get_pNext() { return m_struct.pNext; } 1477 VkDisplayModeCreateFlagsKHR get_flags() { return m_struct.flags; } 1478 void set_flags(VkDisplayModeCreateFlagsKHR inValue) { m_struct.flags = inValue; } 1479 VkDisplayModeParametersKHR get_parameters() { return m_struct.parameters; } 1480 void set_parameters(VkDisplayModeParametersKHR inValue) { m_struct.parameters = inValue; } 1481 1482 1483 private: 1484 VkDisplayModeCreateInfoKHR m_struct; 1485 const VkDisplayModeCreateInfoKHR* m_origStructAddr; 1486 uint32_t m_indent; 1487 const char m_dummy_prefix; 1488 void display_struct_members(); 1489 1490 }; 1491 1492 1493 //class declaration 1494 class vkdisplaymodeparameterskhr_struct_wrapper 1495 { 1496 public: 1497 vkdisplaymodeparameterskhr_struct_wrapper(); 1498 vkdisplaymodeparameterskhr_struct_wrapper(VkDisplayModeParametersKHR* pInStruct); 1499 vkdisplaymodeparameterskhr_struct_wrapper(const VkDisplayModeParametersKHR* pInStruct); 1500 1501 virtual ~vkdisplaymodeparameterskhr_struct_wrapper(); 1502 1503 void display_txt(); 1504 void display_single_txt(); 1505 void display_full_txt(); 1506 1507 void set_indent(uint32_t indent) { m_indent = indent; } 1508 VkExtent2D get_visibleRegion() { return m_struct.visibleRegion; } 1509 void set_visibleRegion(VkExtent2D inValue) { m_struct.visibleRegion = inValue; } 1510 uint32_t get_refreshRate() { return m_struct.refreshRate; } 1511 void set_refreshRate(uint32_t inValue) { m_struct.refreshRate = inValue; } 1512 1513 1514 private: 1515 VkDisplayModeParametersKHR m_struct; 1516 const VkDisplayModeParametersKHR* m_origStructAddr; 1517 uint32_t m_indent; 1518 const char m_dummy_prefix; 1519 void display_struct_members(); 1520 1521 }; 1522 1523 1524 //class declaration 1525 class vkdisplaymodepropertieskhr_struct_wrapper 1526 { 1527 public: 1528 vkdisplaymodepropertieskhr_struct_wrapper(); 1529 vkdisplaymodepropertieskhr_struct_wrapper(VkDisplayModePropertiesKHR* pInStruct); 1530 vkdisplaymodepropertieskhr_struct_wrapper(const VkDisplayModePropertiesKHR* pInStruct); 1531 1532 virtual ~vkdisplaymodepropertieskhr_struct_wrapper(); 1533 1534 void display_txt(); 1535 void display_single_txt(); 1536 void display_full_txt(); 1537 1538 void set_indent(uint32_t indent) { m_indent = indent; } 1539 VkDisplayModeKHR get_displayMode() { return m_struct.displayMode; } 1540 void set_displayMode(VkDisplayModeKHR inValue) { m_struct.displayMode = inValue; } 1541 VkDisplayModeParametersKHR get_parameters() { return m_struct.parameters; } 1542 void set_parameters(VkDisplayModeParametersKHR inValue) { m_struct.parameters = inValue; } 1543 1544 1545 private: 1546 VkDisplayModePropertiesKHR m_struct; 1547 const VkDisplayModePropertiesKHR* m_origStructAddr; 1548 uint32_t m_indent; 1549 const char m_dummy_prefix; 1550 void display_struct_members(); 1551 1552 }; 1553 1554 1555 //class declaration 1556 class vkdisplayplanecapabilitieskhr_struct_wrapper 1557 { 1558 public: 1559 vkdisplayplanecapabilitieskhr_struct_wrapper(); 1560 vkdisplayplanecapabilitieskhr_struct_wrapper(VkDisplayPlaneCapabilitiesKHR* pInStruct); 1561 vkdisplayplanecapabilitieskhr_struct_wrapper(const VkDisplayPlaneCapabilitiesKHR* pInStruct); 1562 1563 virtual ~vkdisplayplanecapabilitieskhr_struct_wrapper(); 1564 1565 void display_txt(); 1566 void display_single_txt(); 1567 void display_full_txt(); 1568 1569 void set_indent(uint32_t indent) { m_indent = indent; } 1570 VkDisplayPlaneAlphaFlagsKHR get_supportedAlpha() { return m_struct.supportedAlpha; } 1571 void set_supportedAlpha(VkDisplayPlaneAlphaFlagsKHR inValue) { m_struct.supportedAlpha = inValue; } 1572 VkOffset2D get_minSrcPosition() { return m_struct.minSrcPosition; } 1573 void set_minSrcPosition(VkOffset2D inValue) { m_struct.minSrcPosition = inValue; } 1574 VkOffset2D get_maxSrcPosition() { return m_struct.maxSrcPosition; } 1575 void set_maxSrcPosition(VkOffset2D inValue) { m_struct.maxSrcPosition = inValue; } 1576 VkExtent2D get_minSrcExtent() { return m_struct.minSrcExtent; } 1577 void set_minSrcExtent(VkExtent2D inValue) { m_struct.minSrcExtent = inValue; } 1578 VkExtent2D get_maxSrcExtent() { return m_struct.maxSrcExtent; } 1579 void set_maxSrcExtent(VkExtent2D inValue) { m_struct.maxSrcExtent = inValue; } 1580 VkOffset2D get_minDstPosition() { return m_struct.minDstPosition; } 1581 void set_minDstPosition(VkOffset2D inValue) { m_struct.minDstPosition = inValue; } 1582 VkOffset2D get_maxDstPosition() { return m_struct.maxDstPosition; } 1583 void set_maxDstPosition(VkOffset2D inValue) { m_struct.maxDstPosition = inValue; } 1584 VkExtent2D get_minDstExtent() { return m_struct.minDstExtent; } 1585 void set_minDstExtent(VkExtent2D inValue) { m_struct.minDstExtent = inValue; } 1586 VkExtent2D get_maxDstExtent() { return m_struct.maxDstExtent; } 1587 void set_maxDstExtent(VkExtent2D inValue) { m_struct.maxDstExtent = inValue; } 1588 1589 1590 private: 1591 VkDisplayPlaneCapabilitiesKHR m_struct; 1592 const VkDisplayPlaneCapabilitiesKHR* m_origStructAddr; 1593 uint32_t m_indent; 1594 const char m_dummy_prefix; 1595 void display_struct_members(); 1596 1597 }; 1598 1599 1600 //class declaration 1601 class vkdisplayplanepropertieskhr_struct_wrapper 1602 { 1603 public: 1604 vkdisplayplanepropertieskhr_struct_wrapper(); 1605 vkdisplayplanepropertieskhr_struct_wrapper(VkDisplayPlanePropertiesKHR* pInStruct); 1606 vkdisplayplanepropertieskhr_struct_wrapper(const VkDisplayPlanePropertiesKHR* pInStruct); 1607 1608 virtual ~vkdisplayplanepropertieskhr_struct_wrapper(); 1609 1610 void display_txt(); 1611 void display_single_txt(); 1612 void display_full_txt(); 1613 1614 void set_indent(uint32_t indent) { m_indent = indent; } 1615 VkDisplayKHR get_currentDisplay() { return m_struct.currentDisplay; } 1616 void set_currentDisplay(VkDisplayKHR inValue) { m_struct.currentDisplay = inValue; } 1617 uint32_t get_currentStackIndex() { return m_struct.currentStackIndex; } 1618 void set_currentStackIndex(uint32_t inValue) { m_struct.currentStackIndex = inValue; } 1619 1620 1621 private: 1622 VkDisplayPlanePropertiesKHR m_struct; 1623 const VkDisplayPlanePropertiesKHR* m_origStructAddr; 1624 uint32_t m_indent; 1625 const char m_dummy_prefix; 1626 void display_struct_members(); 1627 1628 }; 1629 1630 1631 //class declaration 1632 class vkdisplaypresentinfokhr_struct_wrapper 1633 { 1634 public: 1635 vkdisplaypresentinfokhr_struct_wrapper(); 1636 vkdisplaypresentinfokhr_struct_wrapper(VkDisplayPresentInfoKHR* pInStruct); 1637 vkdisplaypresentinfokhr_struct_wrapper(const VkDisplayPresentInfoKHR* pInStruct); 1638 1639 virtual ~vkdisplaypresentinfokhr_struct_wrapper(); 1640 1641 void display_txt(); 1642 void display_single_txt(); 1643 void display_full_txt(); 1644 1645 void set_indent(uint32_t indent) { m_indent = indent; } 1646 VkStructureType get_sType() { return m_struct.sType; } 1647 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1648 const void* get_pNext() { return m_struct.pNext; } 1649 VkRect2D get_srcRect() { return m_struct.srcRect; } 1650 void set_srcRect(VkRect2D inValue) { m_struct.srcRect = inValue; } 1651 VkRect2D get_dstRect() { return m_struct.dstRect; } 1652 void set_dstRect(VkRect2D inValue) { m_struct.dstRect = inValue; } 1653 VkBool32 get_persistent() { return m_struct.persistent; } 1654 void set_persistent(VkBool32 inValue) { m_struct.persistent = inValue; } 1655 1656 1657 private: 1658 VkDisplayPresentInfoKHR m_struct; 1659 const VkDisplayPresentInfoKHR* m_origStructAddr; 1660 uint32_t m_indent; 1661 const char m_dummy_prefix; 1662 void display_struct_members(); 1663 1664 }; 1665 1666 1667 //class declaration 1668 class vkdisplaypropertieskhr_struct_wrapper 1669 { 1670 public: 1671 vkdisplaypropertieskhr_struct_wrapper(); 1672 vkdisplaypropertieskhr_struct_wrapper(VkDisplayPropertiesKHR* pInStruct); 1673 vkdisplaypropertieskhr_struct_wrapper(const VkDisplayPropertiesKHR* pInStruct); 1674 1675 virtual ~vkdisplaypropertieskhr_struct_wrapper(); 1676 1677 void display_txt(); 1678 void display_single_txt(); 1679 void display_full_txt(); 1680 1681 void set_indent(uint32_t indent) { m_indent = indent; } 1682 VkDisplayKHR get_display() { return m_struct.display; } 1683 void set_display(VkDisplayKHR inValue) { m_struct.display = inValue; } 1684 const char* get_displayName() { return m_struct.displayName; } 1685 VkExtent2D get_physicalDimensions() { return m_struct.physicalDimensions; } 1686 void set_physicalDimensions(VkExtent2D inValue) { m_struct.physicalDimensions = inValue; } 1687 VkExtent2D get_physicalResolution() { return m_struct.physicalResolution; } 1688 void set_physicalResolution(VkExtent2D inValue) { m_struct.physicalResolution = inValue; } 1689 VkSurfaceTransformFlagsKHR get_supportedTransforms() { return m_struct.supportedTransforms; } 1690 void set_supportedTransforms(VkSurfaceTransformFlagsKHR inValue) { m_struct.supportedTransforms = inValue; } 1691 VkBool32 get_planeReorderPossible() { return m_struct.planeReorderPossible; } 1692 void set_planeReorderPossible(VkBool32 inValue) { m_struct.planeReorderPossible = inValue; } 1693 VkBool32 get_persistentContent() { return m_struct.persistentContent; } 1694 void set_persistentContent(VkBool32 inValue) { m_struct.persistentContent = inValue; } 1695 1696 1697 private: 1698 VkDisplayPropertiesKHR m_struct; 1699 const VkDisplayPropertiesKHR* m_origStructAddr; 1700 uint32_t m_indent; 1701 const char m_dummy_prefix; 1702 void display_struct_members(); 1703 1704 }; 1705 1706 1707 //class declaration 1708 class vkdisplaysurfacecreateinfokhr_struct_wrapper 1709 { 1710 public: 1711 vkdisplaysurfacecreateinfokhr_struct_wrapper(); 1712 vkdisplaysurfacecreateinfokhr_struct_wrapper(VkDisplaySurfaceCreateInfoKHR* pInStruct); 1713 vkdisplaysurfacecreateinfokhr_struct_wrapper(const VkDisplaySurfaceCreateInfoKHR* pInStruct); 1714 1715 virtual ~vkdisplaysurfacecreateinfokhr_struct_wrapper(); 1716 1717 void display_txt(); 1718 void display_single_txt(); 1719 void display_full_txt(); 1720 1721 void set_indent(uint32_t indent) { m_indent = indent; } 1722 VkStructureType get_sType() { return m_struct.sType; } 1723 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1724 const void* get_pNext() { return m_struct.pNext; } 1725 VkDisplaySurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 1726 void set_flags(VkDisplaySurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 1727 VkDisplayModeKHR get_displayMode() { return m_struct.displayMode; } 1728 void set_displayMode(VkDisplayModeKHR inValue) { m_struct.displayMode = inValue; } 1729 uint32_t get_planeIndex() { return m_struct.planeIndex; } 1730 void set_planeIndex(uint32_t inValue) { m_struct.planeIndex = inValue; } 1731 uint32_t get_planeStackIndex() { return m_struct.planeStackIndex; } 1732 void set_planeStackIndex(uint32_t inValue) { m_struct.planeStackIndex = inValue; } 1733 VkSurfaceTransformFlagBitsKHR get_transform() { return m_struct.transform; } 1734 void set_transform(VkSurfaceTransformFlagBitsKHR inValue) { m_struct.transform = inValue; } 1735 float get_globalAlpha() { return m_struct.globalAlpha; } 1736 void set_globalAlpha(float inValue) { m_struct.globalAlpha = inValue; } 1737 VkDisplayPlaneAlphaFlagBitsKHR get_alphaMode() { return m_struct.alphaMode; } 1738 void set_alphaMode(VkDisplayPlaneAlphaFlagBitsKHR inValue) { m_struct.alphaMode = inValue; } 1739 VkExtent2D get_imageExtent() { return m_struct.imageExtent; } 1740 void set_imageExtent(VkExtent2D inValue) { m_struct.imageExtent = inValue; } 1741 1742 1743 private: 1744 VkDisplaySurfaceCreateInfoKHR m_struct; 1745 const VkDisplaySurfaceCreateInfoKHR* m_origStructAddr; 1746 uint32_t m_indent; 1747 const char m_dummy_prefix; 1748 void display_struct_members(); 1749 1750 }; 1751 1752 1753 //class declaration 1754 class vkdrawindexedindirectcommand_struct_wrapper 1755 { 1756 public: 1757 vkdrawindexedindirectcommand_struct_wrapper(); 1758 vkdrawindexedindirectcommand_struct_wrapper(VkDrawIndexedIndirectCommand* pInStruct); 1759 vkdrawindexedindirectcommand_struct_wrapper(const VkDrawIndexedIndirectCommand* pInStruct); 1760 1761 virtual ~vkdrawindexedindirectcommand_struct_wrapper(); 1762 1763 void display_txt(); 1764 void display_single_txt(); 1765 void display_full_txt(); 1766 1767 void set_indent(uint32_t indent) { m_indent = indent; } 1768 uint32_t get_indexCount() { return m_struct.indexCount; } 1769 void set_indexCount(uint32_t inValue) { m_struct.indexCount = inValue; } 1770 uint32_t get_instanceCount() { return m_struct.instanceCount; } 1771 void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; } 1772 uint32_t get_firstIndex() { return m_struct.firstIndex; } 1773 void set_firstIndex(uint32_t inValue) { m_struct.firstIndex = inValue; } 1774 int32_t get_vertexOffset() { return m_struct.vertexOffset; } 1775 void set_vertexOffset(int32_t inValue) { m_struct.vertexOffset = inValue; } 1776 uint32_t get_firstInstance() { return m_struct.firstInstance; } 1777 void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; } 1778 1779 1780 private: 1781 VkDrawIndexedIndirectCommand m_struct; 1782 const VkDrawIndexedIndirectCommand* m_origStructAddr; 1783 uint32_t m_indent; 1784 const char m_dummy_prefix; 1785 void display_struct_members(); 1786 1787 }; 1788 1789 1790 //class declaration 1791 class vkdrawindirectcommand_struct_wrapper 1792 { 1793 public: 1794 vkdrawindirectcommand_struct_wrapper(); 1795 vkdrawindirectcommand_struct_wrapper(VkDrawIndirectCommand* pInStruct); 1796 vkdrawindirectcommand_struct_wrapper(const VkDrawIndirectCommand* pInStruct); 1797 1798 virtual ~vkdrawindirectcommand_struct_wrapper(); 1799 1800 void display_txt(); 1801 void display_single_txt(); 1802 void display_full_txt(); 1803 1804 void set_indent(uint32_t indent) { m_indent = indent; } 1805 uint32_t get_vertexCount() { return m_struct.vertexCount; } 1806 void set_vertexCount(uint32_t inValue) { m_struct.vertexCount = inValue; } 1807 uint32_t get_instanceCount() { return m_struct.instanceCount; } 1808 void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; } 1809 uint32_t get_firstVertex() { return m_struct.firstVertex; } 1810 void set_firstVertex(uint32_t inValue) { m_struct.firstVertex = inValue; } 1811 uint32_t get_firstInstance() { return m_struct.firstInstance; } 1812 void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; } 1813 1814 1815 private: 1816 VkDrawIndirectCommand m_struct; 1817 const VkDrawIndirectCommand* m_origStructAddr; 1818 uint32_t m_indent; 1819 const char m_dummy_prefix; 1820 void display_struct_members(); 1821 1822 }; 1823 1824 1825 //class declaration 1826 class vkeventcreateinfo_struct_wrapper 1827 { 1828 public: 1829 vkeventcreateinfo_struct_wrapper(); 1830 vkeventcreateinfo_struct_wrapper(VkEventCreateInfo* pInStruct); 1831 vkeventcreateinfo_struct_wrapper(const VkEventCreateInfo* pInStruct); 1832 1833 virtual ~vkeventcreateinfo_struct_wrapper(); 1834 1835 void display_txt(); 1836 void display_single_txt(); 1837 void display_full_txt(); 1838 1839 void set_indent(uint32_t indent) { m_indent = indent; } 1840 VkStructureType get_sType() { return m_struct.sType; } 1841 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1842 const void* get_pNext() { return m_struct.pNext; } 1843 VkEventCreateFlags get_flags() { return m_struct.flags; } 1844 void set_flags(VkEventCreateFlags inValue) { m_struct.flags = inValue; } 1845 1846 1847 private: 1848 VkEventCreateInfo m_struct; 1849 const VkEventCreateInfo* m_origStructAddr; 1850 uint32_t m_indent; 1851 const char m_dummy_prefix; 1852 void display_struct_members(); 1853 1854 }; 1855 1856 1857 //class declaration 1858 class vkexportmemoryallocateinfonv_struct_wrapper 1859 { 1860 public: 1861 vkexportmemoryallocateinfonv_struct_wrapper(); 1862 vkexportmemoryallocateinfonv_struct_wrapper(VkExportMemoryAllocateInfoNV* pInStruct); 1863 vkexportmemoryallocateinfonv_struct_wrapper(const VkExportMemoryAllocateInfoNV* pInStruct); 1864 1865 virtual ~vkexportmemoryallocateinfonv_struct_wrapper(); 1866 1867 void display_txt(); 1868 void display_single_txt(); 1869 void display_full_txt(); 1870 1871 void set_indent(uint32_t indent) { m_indent = indent; } 1872 VkStructureType get_sType() { return m_struct.sType; } 1873 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1874 const void* get_pNext() { return m_struct.pNext; } 1875 VkExternalMemoryHandleTypeFlagsNV get_handleTypes() { return m_struct.handleTypes; } 1876 void set_handleTypes(VkExternalMemoryHandleTypeFlagsNV inValue) { m_struct.handleTypes = inValue; } 1877 1878 1879 private: 1880 VkExportMemoryAllocateInfoNV m_struct; 1881 const VkExportMemoryAllocateInfoNV* m_origStructAddr; 1882 uint32_t m_indent; 1883 const char m_dummy_prefix; 1884 void display_struct_members(); 1885 1886 }; 1887 1888 1889 //class declaration 1890 class vkexportmemorywin32handleinfonv_struct_wrapper 1891 { 1892 public: 1893 vkexportmemorywin32handleinfonv_struct_wrapper(); 1894 vkexportmemorywin32handleinfonv_struct_wrapper(VkExportMemoryWin32HandleInfoNV* pInStruct); 1895 vkexportmemorywin32handleinfonv_struct_wrapper(const VkExportMemoryWin32HandleInfoNV* pInStruct); 1896 1897 virtual ~vkexportmemorywin32handleinfonv_struct_wrapper(); 1898 1899 void display_txt(); 1900 void display_single_txt(); 1901 void display_full_txt(); 1902 1903 void set_indent(uint32_t indent) { m_indent = indent; } 1904 VkStructureType get_sType() { return m_struct.sType; } 1905 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 1906 const void* get_pNext() { return m_struct.pNext; } 1907 const SECURITY_ATTRIBUTES* get_pAttributes() { return m_struct.pAttributes; } 1908 DWORD get_dwAccess() { return m_struct.dwAccess; } 1909 void set_dwAccess(DWORD inValue) { m_struct.dwAccess = inValue; } 1910 1911 1912 private: 1913 VkExportMemoryWin32HandleInfoNV m_struct; 1914 const VkExportMemoryWin32HandleInfoNV* m_origStructAddr; 1915 uint32_t m_indent; 1916 const char m_dummy_prefix; 1917 void display_struct_members(); 1918 1919 }; 1920 1921 1922 //class declaration 1923 class vkextensionproperties_struct_wrapper 1924 { 1925 public: 1926 vkextensionproperties_struct_wrapper(); 1927 vkextensionproperties_struct_wrapper(VkExtensionProperties* pInStruct); 1928 vkextensionproperties_struct_wrapper(const VkExtensionProperties* pInStruct); 1929 1930 virtual ~vkextensionproperties_struct_wrapper(); 1931 1932 void display_txt(); 1933 void display_single_txt(); 1934 void display_full_txt(); 1935 1936 void set_indent(uint32_t indent) { m_indent = indent; } 1937 uint32_t get_specVersion() { return m_struct.specVersion; } 1938 void set_specVersion(uint32_t inValue) { m_struct.specVersion = inValue; } 1939 1940 1941 private: 1942 VkExtensionProperties m_struct; 1943 const VkExtensionProperties* m_origStructAddr; 1944 uint32_t m_indent; 1945 const char m_dummy_prefix; 1946 void display_struct_members(); 1947 1948 }; 1949 1950 1951 //class declaration 1952 class vkextent2d_struct_wrapper 1953 { 1954 public: 1955 vkextent2d_struct_wrapper(); 1956 vkextent2d_struct_wrapper(VkExtent2D* pInStruct); 1957 vkextent2d_struct_wrapper(const VkExtent2D* pInStruct); 1958 1959 virtual ~vkextent2d_struct_wrapper(); 1960 1961 void display_txt(); 1962 void display_single_txt(); 1963 void display_full_txt(); 1964 1965 void set_indent(uint32_t indent) { m_indent = indent; } 1966 uint32_t get_width() { return m_struct.width; } 1967 void set_width(uint32_t inValue) { m_struct.width = inValue; } 1968 uint32_t get_height() { return m_struct.height; } 1969 void set_height(uint32_t inValue) { m_struct.height = inValue; } 1970 1971 1972 private: 1973 VkExtent2D m_struct; 1974 const VkExtent2D* m_origStructAddr; 1975 uint32_t m_indent; 1976 const char m_dummy_prefix; 1977 void display_struct_members(); 1978 1979 }; 1980 1981 1982 //class declaration 1983 class vkextent3d_struct_wrapper 1984 { 1985 public: 1986 vkextent3d_struct_wrapper(); 1987 vkextent3d_struct_wrapper(VkExtent3D* pInStruct); 1988 vkextent3d_struct_wrapper(const VkExtent3D* pInStruct); 1989 1990 virtual ~vkextent3d_struct_wrapper(); 1991 1992 void display_txt(); 1993 void display_single_txt(); 1994 void display_full_txt(); 1995 1996 void set_indent(uint32_t indent) { m_indent = indent; } 1997 uint32_t get_width() { return m_struct.width; } 1998 void set_width(uint32_t inValue) { m_struct.width = inValue; } 1999 uint32_t get_height() { return m_struct.height; } 2000 void set_height(uint32_t inValue) { m_struct.height = inValue; } 2001 uint32_t get_depth() { return m_struct.depth; } 2002 void set_depth(uint32_t inValue) { m_struct.depth = inValue; } 2003 2004 2005 private: 2006 VkExtent3D m_struct; 2007 const VkExtent3D* m_origStructAddr; 2008 uint32_t m_indent; 2009 const char m_dummy_prefix; 2010 void display_struct_members(); 2011 2012 }; 2013 2014 2015 //class declaration 2016 class vkexternalimageformatpropertiesnv_struct_wrapper 2017 { 2018 public: 2019 vkexternalimageformatpropertiesnv_struct_wrapper(); 2020 vkexternalimageformatpropertiesnv_struct_wrapper(VkExternalImageFormatPropertiesNV* pInStruct); 2021 vkexternalimageformatpropertiesnv_struct_wrapper(const VkExternalImageFormatPropertiesNV* pInStruct); 2022 2023 virtual ~vkexternalimageformatpropertiesnv_struct_wrapper(); 2024 2025 void display_txt(); 2026 void display_single_txt(); 2027 void display_full_txt(); 2028 2029 void set_indent(uint32_t indent) { m_indent = indent; } 2030 VkImageFormatProperties get_imageFormatProperties() { return m_struct.imageFormatProperties; } 2031 void set_imageFormatProperties(VkImageFormatProperties inValue) { m_struct.imageFormatProperties = inValue; } 2032 VkExternalMemoryFeatureFlagsNV get_externalMemoryFeatures() { return m_struct.externalMemoryFeatures; } 2033 void set_externalMemoryFeatures(VkExternalMemoryFeatureFlagsNV inValue) { m_struct.externalMemoryFeatures = inValue; } 2034 VkExternalMemoryHandleTypeFlagsNV get_exportFromImportedHandleTypes() { return m_struct.exportFromImportedHandleTypes; } 2035 void set_exportFromImportedHandleTypes(VkExternalMemoryHandleTypeFlagsNV inValue) { m_struct.exportFromImportedHandleTypes = inValue; } 2036 VkExternalMemoryHandleTypeFlagsNV get_compatibleHandleTypes() { return m_struct.compatibleHandleTypes; } 2037 void set_compatibleHandleTypes(VkExternalMemoryHandleTypeFlagsNV inValue) { m_struct.compatibleHandleTypes = inValue; } 2038 2039 2040 private: 2041 VkExternalImageFormatPropertiesNV m_struct; 2042 const VkExternalImageFormatPropertiesNV* m_origStructAddr; 2043 uint32_t m_indent; 2044 const char m_dummy_prefix; 2045 void display_struct_members(); 2046 2047 }; 2048 2049 2050 //class declaration 2051 class vkexternalmemoryimagecreateinfonv_struct_wrapper 2052 { 2053 public: 2054 vkexternalmemoryimagecreateinfonv_struct_wrapper(); 2055 vkexternalmemoryimagecreateinfonv_struct_wrapper(VkExternalMemoryImageCreateInfoNV* pInStruct); 2056 vkexternalmemoryimagecreateinfonv_struct_wrapper(const VkExternalMemoryImageCreateInfoNV* pInStruct); 2057 2058 virtual ~vkexternalmemoryimagecreateinfonv_struct_wrapper(); 2059 2060 void display_txt(); 2061 void display_single_txt(); 2062 void display_full_txt(); 2063 2064 void set_indent(uint32_t indent) { m_indent = indent; } 2065 VkStructureType get_sType() { return m_struct.sType; } 2066 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2067 const void* get_pNext() { return m_struct.pNext; } 2068 VkExternalMemoryHandleTypeFlagsNV get_handleTypes() { return m_struct.handleTypes; } 2069 void set_handleTypes(VkExternalMemoryHandleTypeFlagsNV inValue) { m_struct.handleTypes = inValue; } 2070 2071 2072 private: 2073 VkExternalMemoryImageCreateInfoNV m_struct; 2074 const VkExternalMemoryImageCreateInfoNV* m_origStructAddr; 2075 uint32_t m_indent; 2076 const char m_dummy_prefix; 2077 void display_struct_members(); 2078 2079 }; 2080 2081 2082 //class declaration 2083 class vkfencecreateinfo_struct_wrapper 2084 { 2085 public: 2086 vkfencecreateinfo_struct_wrapper(); 2087 vkfencecreateinfo_struct_wrapper(VkFenceCreateInfo* pInStruct); 2088 vkfencecreateinfo_struct_wrapper(const VkFenceCreateInfo* pInStruct); 2089 2090 virtual ~vkfencecreateinfo_struct_wrapper(); 2091 2092 void display_txt(); 2093 void display_single_txt(); 2094 void display_full_txt(); 2095 2096 void set_indent(uint32_t indent) { m_indent = indent; } 2097 VkStructureType get_sType() { return m_struct.sType; } 2098 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2099 const void* get_pNext() { return m_struct.pNext; } 2100 VkFenceCreateFlags get_flags() { return m_struct.flags; } 2101 void set_flags(VkFenceCreateFlags inValue) { m_struct.flags = inValue; } 2102 2103 2104 private: 2105 VkFenceCreateInfo m_struct; 2106 const VkFenceCreateInfo* m_origStructAddr; 2107 uint32_t m_indent; 2108 const char m_dummy_prefix; 2109 void display_struct_members(); 2110 2111 }; 2112 2113 2114 //class declaration 2115 class vkformatproperties_struct_wrapper 2116 { 2117 public: 2118 vkformatproperties_struct_wrapper(); 2119 vkformatproperties_struct_wrapper(VkFormatProperties* pInStruct); 2120 vkformatproperties_struct_wrapper(const VkFormatProperties* pInStruct); 2121 2122 virtual ~vkformatproperties_struct_wrapper(); 2123 2124 void display_txt(); 2125 void display_single_txt(); 2126 void display_full_txt(); 2127 2128 void set_indent(uint32_t indent) { m_indent = indent; } 2129 VkFormatFeatureFlags get_linearTilingFeatures() { return m_struct.linearTilingFeatures; } 2130 void set_linearTilingFeatures(VkFormatFeatureFlags inValue) { m_struct.linearTilingFeatures = inValue; } 2131 VkFormatFeatureFlags get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; } 2132 void set_optimalTilingFeatures(VkFormatFeatureFlags inValue) { m_struct.optimalTilingFeatures = inValue; } 2133 VkFormatFeatureFlags get_bufferFeatures() { return m_struct.bufferFeatures; } 2134 void set_bufferFeatures(VkFormatFeatureFlags inValue) { m_struct.bufferFeatures = inValue; } 2135 2136 2137 private: 2138 VkFormatProperties m_struct; 2139 const VkFormatProperties* m_origStructAddr; 2140 uint32_t m_indent; 2141 const char m_dummy_prefix; 2142 void display_struct_members(); 2143 2144 }; 2145 2146 2147 //class declaration 2148 class vkframebuffercreateinfo_struct_wrapper 2149 { 2150 public: 2151 vkframebuffercreateinfo_struct_wrapper(); 2152 vkframebuffercreateinfo_struct_wrapper(VkFramebufferCreateInfo* pInStruct); 2153 vkframebuffercreateinfo_struct_wrapper(const VkFramebufferCreateInfo* pInStruct); 2154 2155 virtual ~vkframebuffercreateinfo_struct_wrapper(); 2156 2157 void display_txt(); 2158 void display_single_txt(); 2159 void display_full_txt(); 2160 2161 void set_indent(uint32_t indent) { m_indent = indent; } 2162 VkStructureType get_sType() { return m_struct.sType; } 2163 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2164 const void* get_pNext() { return m_struct.pNext; } 2165 VkFramebufferCreateFlags get_flags() { return m_struct.flags; } 2166 void set_flags(VkFramebufferCreateFlags inValue) { m_struct.flags = inValue; } 2167 VkRenderPass get_renderPass() { return m_struct.renderPass; } 2168 void set_renderPass(VkRenderPass inValue) { m_struct.renderPass = inValue; } 2169 uint32_t get_attachmentCount() { return m_struct.attachmentCount; } 2170 void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; } 2171 uint32_t get_width() { return m_struct.width; } 2172 void set_width(uint32_t inValue) { m_struct.width = inValue; } 2173 uint32_t get_height() { return m_struct.height; } 2174 void set_height(uint32_t inValue) { m_struct.height = inValue; } 2175 uint32_t get_layers() { return m_struct.layers; } 2176 void set_layers(uint32_t inValue) { m_struct.layers = inValue; } 2177 2178 2179 private: 2180 VkFramebufferCreateInfo m_struct; 2181 const VkFramebufferCreateInfo* m_origStructAddr; 2182 uint32_t m_indent; 2183 const char m_dummy_prefix; 2184 void display_struct_members(); 2185 2186 }; 2187 2188 2189 //class declaration 2190 class vkgraphicspipelinecreateinfo_struct_wrapper 2191 { 2192 public: 2193 vkgraphicspipelinecreateinfo_struct_wrapper(); 2194 vkgraphicspipelinecreateinfo_struct_wrapper(VkGraphicsPipelineCreateInfo* pInStruct); 2195 vkgraphicspipelinecreateinfo_struct_wrapper(const VkGraphicsPipelineCreateInfo* pInStruct); 2196 2197 virtual ~vkgraphicspipelinecreateinfo_struct_wrapper(); 2198 2199 void display_txt(); 2200 void display_single_txt(); 2201 void display_full_txt(); 2202 2203 void set_indent(uint32_t indent) { m_indent = indent; } 2204 VkStructureType get_sType() { return m_struct.sType; } 2205 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2206 const void* get_pNext() { return m_struct.pNext; } 2207 VkPipelineCreateFlags get_flags() { return m_struct.flags; } 2208 void set_flags(VkPipelineCreateFlags inValue) { m_struct.flags = inValue; } 2209 uint32_t get_stageCount() { return m_struct.stageCount; } 2210 void set_stageCount(uint32_t inValue) { m_struct.stageCount = inValue; } 2211 const VkPipelineVertexInputStateCreateInfo* get_pVertexInputState() { return m_struct.pVertexInputState; } 2212 const VkPipelineInputAssemblyStateCreateInfo* get_pInputAssemblyState() { return m_struct.pInputAssemblyState; } 2213 const VkPipelineTessellationStateCreateInfo* get_pTessellationState() { return m_struct.pTessellationState; } 2214 const VkPipelineViewportStateCreateInfo* get_pViewportState() { return m_struct.pViewportState; } 2215 const VkPipelineRasterizationStateCreateInfo* get_pRasterizationState() { return m_struct.pRasterizationState; } 2216 const VkPipelineMultisampleStateCreateInfo* get_pMultisampleState() { return m_struct.pMultisampleState; } 2217 const VkPipelineDepthStencilStateCreateInfo* get_pDepthStencilState() { return m_struct.pDepthStencilState; } 2218 const VkPipelineColorBlendStateCreateInfo* get_pColorBlendState() { return m_struct.pColorBlendState; } 2219 const VkPipelineDynamicStateCreateInfo* get_pDynamicState() { return m_struct.pDynamicState; } 2220 VkPipelineLayout get_layout() { return m_struct.layout; } 2221 void set_layout(VkPipelineLayout inValue) { m_struct.layout = inValue; } 2222 VkRenderPass get_renderPass() { return m_struct.renderPass; } 2223 void set_renderPass(VkRenderPass inValue) { m_struct.renderPass = inValue; } 2224 uint32_t get_subpass() { return m_struct.subpass; } 2225 void set_subpass(uint32_t inValue) { m_struct.subpass = inValue; } 2226 VkPipeline get_basePipelineHandle() { return m_struct.basePipelineHandle; } 2227 void set_basePipelineHandle(VkPipeline inValue) { m_struct.basePipelineHandle = inValue; } 2228 int32_t get_basePipelineIndex() { return m_struct.basePipelineIndex; } 2229 void set_basePipelineIndex(int32_t inValue) { m_struct.basePipelineIndex = inValue; } 2230 2231 2232 private: 2233 VkGraphicsPipelineCreateInfo m_struct; 2234 const VkGraphicsPipelineCreateInfo* m_origStructAddr; 2235 uint32_t m_indent; 2236 const char m_dummy_prefix; 2237 void display_struct_members(); 2238 2239 }; 2240 2241 2242 //class declaration 2243 class vkimageblit_struct_wrapper 2244 { 2245 public: 2246 vkimageblit_struct_wrapper(); 2247 vkimageblit_struct_wrapper(VkImageBlit* pInStruct); 2248 vkimageblit_struct_wrapper(const VkImageBlit* pInStruct); 2249 2250 virtual ~vkimageblit_struct_wrapper(); 2251 2252 void display_txt(); 2253 void display_single_txt(); 2254 void display_full_txt(); 2255 2256 void set_indent(uint32_t indent) { m_indent = indent; } 2257 VkImageSubresourceLayers get_srcSubresource() { return m_struct.srcSubresource; } 2258 void set_srcSubresource(VkImageSubresourceLayers inValue) { m_struct.srcSubresource = inValue; } 2259 VkImageSubresourceLayers get_dstSubresource() { return m_struct.dstSubresource; } 2260 void set_dstSubresource(VkImageSubresourceLayers inValue) { m_struct.dstSubresource = inValue; } 2261 2262 2263 private: 2264 VkImageBlit m_struct; 2265 const VkImageBlit* m_origStructAddr; 2266 uint32_t m_indent; 2267 const char m_dummy_prefix; 2268 void display_struct_members(); 2269 2270 }; 2271 2272 2273 //class declaration 2274 class vkimagecopy_struct_wrapper 2275 { 2276 public: 2277 vkimagecopy_struct_wrapper(); 2278 vkimagecopy_struct_wrapper(VkImageCopy* pInStruct); 2279 vkimagecopy_struct_wrapper(const VkImageCopy* pInStruct); 2280 2281 virtual ~vkimagecopy_struct_wrapper(); 2282 2283 void display_txt(); 2284 void display_single_txt(); 2285 void display_full_txt(); 2286 2287 void set_indent(uint32_t indent) { m_indent = indent; } 2288 VkImageSubresourceLayers get_srcSubresource() { return m_struct.srcSubresource; } 2289 void set_srcSubresource(VkImageSubresourceLayers inValue) { m_struct.srcSubresource = inValue; } 2290 VkOffset3D get_srcOffset() { return m_struct.srcOffset; } 2291 void set_srcOffset(VkOffset3D inValue) { m_struct.srcOffset = inValue; } 2292 VkImageSubresourceLayers get_dstSubresource() { return m_struct.dstSubresource; } 2293 void set_dstSubresource(VkImageSubresourceLayers inValue) { m_struct.dstSubresource = inValue; } 2294 VkOffset3D get_dstOffset() { return m_struct.dstOffset; } 2295 void set_dstOffset(VkOffset3D inValue) { m_struct.dstOffset = inValue; } 2296 VkExtent3D get_extent() { return m_struct.extent; } 2297 void set_extent(VkExtent3D inValue) { m_struct.extent = inValue; } 2298 2299 2300 private: 2301 VkImageCopy m_struct; 2302 const VkImageCopy* m_origStructAddr; 2303 uint32_t m_indent; 2304 const char m_dummy_prefix; 2305 void display_struct_members(); 2306 2307 }; 2308 2309 2310 //class declaration 2311 class vkimagecreateinfo_struct_wrapper 2312 { 2313 public: 2314 vkimagecreateinfo_struct_wrapper(); 2315 vkimagecreateinfo_struct_wrapper(VkImageCreateInfo* pInStruct); 2316 vkimagecreateinfo_struct_wrapper(const VkImageCreateInfo* pInStruct); 2317 2318 virtual ~vkimagecreateinfo_struct_wrapper(); 2319 2320 void display_txt(); 2321 void display_single_txt(); 2322 void display_full_txt(); 2323 2324 void set_indent(uint32_t indent) { m_indent = indent; } 2325 VkStructureType get_sType() { return m_struct.sType; } 2326 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2327 const void* get_pNext() { return m_struct.pNext; } 2328 VkImageCreateFlags get_flags() { return m_struct.flags; } 2329 void set_flags(VkImageCreateFlags inValue) { m_struct.flags = inValue; } 2330 VkImageType get_imageType() { return m_struct.imageType; } 2331 void set_imageType(VkImageType inValue) { m_struct.imageType = inValue; } 2332 VkFormat get_format() { return m_struct.format; } 2333 void set_format(VkFormat inValue) { m_struct.format = inValue; } 2334 VkExtent3D get_extent() { return m_struct.extent; } 2335 void set_extent(VkExtent3D inValue) { m_struct.extent = inValue; } 2336 uint32_t get_mipLevels() { return m_struct.mipLevels; } 2337 void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; } 2338 uint32_t get_arrayLayers() { return m_struct.arrayLayers; } 2339 void set_arrayLayers(uint32_t inValue) { m_struct.arrayLayers = inValue; } 2340 VkSampleCountFlagBits get_samples() { return m_struct.samples; } 2341 void set_samples(VkSampleCountFlagBits inValue) { m_struct.samples = inValue; } 2342 VkImageTiling get_tiling() { return m_struct.tiling; } 2343 void set_tiling(VkImageTiling inValue) { m_struct.tiling = inValue; } 2344 VkImageUsageFlags get_usage() { return m_struct.usage; } 2345 void set_usage(VkImageUsageFlags inValue) { m_struct.usage = inValue; } 2346 VkSharingMode get_sharingMode() { return m_struct.sharingMode; } 2347 void set_sharingMode(VkSharingMode inValue) { m_struct.sharingMode = inValue; } 2348 uint32_t get_queueFamilyIndexCount() { return m_struct.queueFamilyIndexCount; } 2349 void set_queueFamilyIndexCount(uint32_t inValue) { m_struct.queueFamilyIndexCount = inValue; } 2350 VkImageLayout get_initialLayout() { return m_struct.initialLayout; } 2351 void set_initialLayout(VkImageLayout inValue) { m_struct.initialLayout = inValue; } 2352 2353 2354 private: 2355 VkImageCreateInfo m_struct; 2356 const VkImageCreateInfo* m_origStructAddr; 2357 uint32_t m_indent; 2358 const char m_dummy_prefix; 2359 void display_struct_members(); 2360 2361 }; 2362 2363 2364 //class declaration 2365 class vkimageformatproperties_struct_wrapper 2366 { 2367 public: 2368 vkimageformatproperties_struct_wrapper(); 2369 vkimageformatproperties_struct_wrapper(VkImageFormatProperties* pInStruct); 2370 vkimageformatproperties_struct_wrapper(const VkImageFormatProperties* pInStruct); 2371 2372 virtual ~vkimageformatproperties_struct_wrapper(); 2373 2374 void display_txt(); 2375 void display_single_txt(); 2376 void display_full_txt(); 2377 2378 void set_indent(uint32_t indent) { m_indent = indent; } 2379 VkExtent3D get_maxExtent() { return m_struct.maxExtent; } 2380 void set_maxExtent(VkExtent3D inValue) { m_struct.maxExtent = inValue; } 2381 uint32_t get_maxMipLevels() { return m_struct.maxMipLevels; } 2382 void set_maxMipLevels(uint32_t inValue) { m_struct.maxMipLevels = inValue; } 2383 uint32_t get_maxArrayLayers() { return m_struct.maxArrayLayers; } 2384 void set_maxArrayLayers(uint32_t inValue) { m_struct.maxArrayLayers = inValue; } 2385 VkSampleCountFlags get_sampleCounts() { return m_struct.sampleCounts; } 2386 void set_sampleCounts(VkSampleCountFlags inValue) { m_struct.sampleCounts = inValue; } 2387 VkDeviceSize get_maxResourceSize() { return m_struct.maxResourceSize; } 2388 void set_maxResourceSize(VkDeviceSize inValue) { m_struct.maxResourceSize = inValue; } 2389 2390 2391 private: 2392 VkImageFormatProperties m_struct; 2393 const VkImageFormatProperties* 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 vkimagememorybarrier_struct_wrapper 2403 { 2404 public: 2405 vkimagememorybarrier_struct_wrapper(); 2406 vkimagememorybarrier_struct_wrapper(VkImageMemoryBarrier* pInStruct); 2407 vkimagememorybarrier_struct_wrapper(const VkImageMemoryBarrier* pInStruct); 2408 2409 virtual ~vkimagememorybarrier_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 VkAccessFlags get_srcAccessMask() { return m_struct.srcAccessMask; } 2420 void set_srcAccessMask(VkAccessFlags inValue) { m_struct.srcAccessMask = inValue; } 2421 VkAccessFlags get_dstAccessMask() { return m_struct.dstAccessMask; } 2422 void set_dstAccessMask(VkAccessFlags inValue) { m_struct.dstAccessMask = inValue; } 2423 VkImageLayout get_oldLayout() { return m_struct.oldLayout; } 2424 void set_oldLayout(VkImageLayout inValue) { m_struct.oldLayout = inValue; } 2425 VkImageLayout get_newLayout() { return m_struct.newLayout; } 2426 void set_newLayout(VkImageLayout inValue) { m_struct.newLayout = inValue; } 2427 uint32_t get_srcQueueFamilyIndex() { return m_struct.srcQueueFamilyIndex; } 2428 void set_srcQueueFamilyIndex(uint32_t inValue) { m_struct.srcQueueFamilyIndex = inValue; } 2429 uint32_t get_dstQueueFamilyIndex() { return m_struct.dstQueueFamilyIndex; } 2430 void set_dstQueueFamilyIndex(uint32_t inValue) { m_struct.dstQueueFamilyIndex = inValue; } 2431 VkImage get_image() { return m_struct.image; } 2432 void set_image(VkImage inValue) { m_struct.image = inValue; } 2433 VkImageSubresourceRange get_subresourceRange() { return m_struct.subresourceRange; } 2434 void set_subresourceRange(VkImageSubresourceRange inValue) { m_struct.subresourceRange = inValue; } 2435 2436 2437 private: 2438 VkImageMemoryBarrier m_struct; 2439 const VkImageMemoryBarrier* m_origStructAddr; 2440 uint32_t m_indent; 2441 const char m_dummy_prefix; 2442 void display_struct_members(); 2443 2444 }; 2445 2446 2447 //class declaration 2448 class vkimageresolve_struct_wrapper 2449 { 2450 public: 2451 vkimageresolve_struct_wrapper(); 2452 vkimageresolve_struct_wrapper(VkImageResolve* pInStruct); 2453 vkimageresolve_struct_wrapper(const VkImageResolve* pInStruct); 2454 2455 virtual ~vkimageresolve_struct_wrapper(); 2456 2457 void display_txt(); 2458 void display_single_txt(); 2459 void display_full_txt(); 2460 2461 void set_indent(uint32_t indent) { m_indent = indent; } 2462 VkImageSubresourceLayers get_srcSubresource() { return m_struct.srcSubresource; } 2463 void set_srcSubresource(VkImageSubresourceLayers inValue) { m_struct.srcSubresource = inValue; } 2464 VkOffset3D get_srcOffset() { return m_struct.srcOffset; } 2465 void set_srcOffset(VkOffset3D inValue) { m_struct.srcOffset = inValue; } 2466 VkImageSubresourceLayers get_dstSubresource() { return m_struct.dstSubresource; } 2467 void set_dstSubresource(VkImageSubresourceLayers inValue) { m_struct.dstSubresource = inValue; } 2468 VkOffset3D get_dstOffset() { return m_struct.dstOffset; } 2469 void set_dstOffset(VkOffset3D inValue) { m_struct.dstOffset = inValue; } 2470 VkExtent3D get_extent() { return m_struct.extent; } 2471 void set_extent(VkExtent3D inValue) { m_struct.extent = inValue; } 2472 2473 2474 private: 2475 VkImageResolve m_struct; 2476 const VkImageResolve* m_origStructAddr; 2477 uint32_t m_indent; 2478 const char m_dummy_prefix; 2479 void display_struct_members(); 2480 2481 }; 2482 2483 2484 //class declaration 2485 class vkimagesubresource_struct_wrapper 2486 { 2487 public: 2488 vkimagesubresource_struct_wrapper(); 2489 vkimagesubresource_struct_wrapper(VkImageSubresource* pInStruct); 2490 vkimagesubresource_struct_wrapper(const VkImageSubresource* pInStruct); 2491 2492 virtual ~vkimagesubresource_struct_wrapper(); 2493 2494 void display_txt(); 2495 void display_single_txt(); 2496 void display_full_txt(); 2497 2498 void set_indent(uint32_t indent) { m_indent = indent; } 2499 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 2500 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 2501 uint32_t get_mipLevel() { return m_struct.mipLevel; } 2502 void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; } 2503 uint32_t get_arrayLayer() { return m_struct.arrayLayer; } 2504 void set_arrayLayer(uint32_t inValue) { m_struct.arrayLayer = inValue; } 2505 2506 2507 private: 2508 VkImageSubresource m_struct; 2509 const VkImageSubresource* m_origStructAddr; 2510 uint32_t m_indent; 2511 const char m_dummy_prefix; 2512 void display_struct_members(); 2513 2514 }; 2515 2516 2517 //class declaration 2518 class vkimagesubresourcelayers_struct_wrapper 2519 { 2520 public: 2521 vkimagesubresourcelayers_struct_wrapper(); 2522 vkimagesubresourcelayers_struct_wrapper(VkImageSubresourceLayers* pInStruct); 2523 vkimagesubresourcelayers_struct_wrapper(const VkImageSubresourceLayers* pInStruct); 2524 2525 virtual ~vkimagesubresourcelayers_struct_wrapper(); 2526 2527 void display_txt(); 2528 void display_single_txt(); 2529 void display_full_txt(); 2530 2531 void set_indent(uint32_t indent) { m_indent = indent; } 2532 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 2533 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 2534 uint32_t get_mipLevel() { return m_struct.mipLevel; } 2535 void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; } 2536 uint32_t get_baseArrayLayer() { return m_struct.baseArrayLayer; } 2537 void set_baseArrayLayer(uint32_t inValue) { m_struct.baseArrayLayer = inValue; } 2538 uint32_t get_layerCount() { return m_struct.layerCount; } 2539 void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; } 2540 2541 2542 private: 2543 VkImageSubresourceLayers m_struct; 2544 const VkImageSubresourceLayers* m_origStructAddr; 2545 uint32_t m_indent; 2546 const char m_dummy_prefix; 2547 void display_struct_members(); 2548 2549 }; 2550 2551 2552 //class declaration 2553 class vkimagesubresourcerange_struct_wrapper 2554 { 2555 public: 2556 vkimagesubresourcerange_struct_wrapper(); 2557 vkimagesubresourcerange_struct_wrapper(VkImageSubresourceRange* pInStruct); 2558 vkimagesubresourcerange_struct_wrapper(const VkImageSubresourceRange* pInStruct); 2559 2560 virtual ~vkimagesubresourcerange_struct_wrapper(); 2561 2562 void display_txt(); 2563 void display_single_txt(); 2564 void display_full_txt(); 2565 2566 void set_indent(uint32_t indent) { m_indent = indent; } 2567 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 2568 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 2569 uint32_t get_baseMipLevel() { return m_struct.baseMipLevel; } 2570 void set_baseMipLevel(uint32_t inValue) { m_struct.baseMipLevel = inValue; } 2571 uint32_t get_levelCount() { return m_struct.levelCount; } 2572 void set_levelCount(uint32_t inValue) { m_struct.levelCount = inValue; } 2573 uint32_t get_baseArrayLayer() { return m_struct.baseArrayLayer; } 2574 void set_baseArrayLayer(uint32_t inValue) { m_struct.baseArrayLayer = inValue; } 2575 uint32_t get_layerCount() { return m_struct.layerCount; } 2576 void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; } 2577 2578 2579 private: 2580 VkImageSubresourceRange m_struct; 2581 const VkImageSubresourceRange* m_origStructAddr; 2582 uint32_t m_indent; 2583 const char m_dummy_prefix; 2584 void display_struct_members(); 2585 2586 }; 2587 2588 2589 //class declaration 2590 class vkimageviewcreateinfo_struct_wrapper 2591 { 2592 public: 2593 vkimageviewcreateinfo_struct_wrapper(); 2594 vkimageviewcreateinfo_struct_wrapper(VkImageViewCreateInfo* pInStruct); 2595 vkimageviewcreateinfo_struct_wrapper(const VkImageViewCreateInfo* pInStruct); 2596 2597 virtual ~vkimageviewcreateinfo_struct_wrapper(); 2598 2599 void display_txt(); 2600 void display_single_txt(); 2601 void display_full_txt(); 2602 2603 void set_indent(uint32_t indent) { m_indent = indent; } 2604 VkStructureType get_sType() { return m_struct.sType; } 2605 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2606 const void* get_pNext() { return m_struct.pNext; } 2607 VkImageViewCreateFlags get_flags() { return m_struct.flags; } 2608 void set_flags(VkImageViewCreateFlags inValue) { m_struct.flags = inValue; } 2609 VkImage get_image() { return m_struct.image; } 2610 void set_image(VkImage inValue) { m_struct.image = inValue; } 2611 VkImageViewType get_viewType() { return m_struct.viewType; } 2612 void set_viewType(VkImageViewType inValue) { m_struct.viewType = inValue; } 2613 VkFormat get_format() { return m_struct.format; } 2614 void set_format(VkFormat inValue) { m_struct.format = inValue; } 2615 VkComponentMapping get_components() { return m_struct.components; } 2616 void set_components(VkComponentMapping inValue) { m_struct.components = inValue; } 2617 VkImageSubresourceRange get_subresourceRange() { return m_struct.subresourceRange; } 2618 void set_subresourceRange(VkImageSubresourceRange inValue) { m_struct.subresourceRange = inValue; } 2619 2620 2621 private: 2622 VkImageViewCreateInfo m_struct; 2623 const VkImageViewCreateInfo* m_origStructAddr; 2624 uint32_t m_indent; 2625 const char m_dummy_prefix; 2626 void display_struct_members(); 2627 2628 }; 2629 2630 2631 //class declaration 2632 class vkimportmemorywin32handleinfonv_struct_wrapper 2633 { 2634 public: 2635 vkimportmemorywin32handleinfonv_struct_wrapper(); 2636 vkimportmemorywin32handleinfonv_struct_wrapper(VkImportMemoryWin32HandleInfoNV* pInStruct); 2637 vkimportmemorywin32handleinfonv_struct_wrapper(const VkImportMemoryWin32HandleInfoNV* pInStruct); 2638 2639 virtual ~vkimportmemorywin32handleinfonv_struct_wrapper(); 2640 2641 void display_txt(); 2642 void display_single_txt(); 2643 void display_full_txt(); 2644 2645 void set_indent(uint32_t indent) { m_indent = indent; } 2646 VkStructureType get_sType() { return m_struct.sType; } 2647 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2648 const void* get_pNext() { return m_struct.pNext; } 2649 VkExternalMemoryHandleTypeFlagsNV get_handleType() { return m_struct.handleType; } 2650 void set_handleType(VkExternalMemoryHandleTypeFlagsNV inValue) { m_struct.handleType = inValue; } 2651 HANDLE get_handle() { return m_struct.handle; } 2652 void set_handle(HANDLE inValue) { m_struct.handle = inValue; } 2653 2654 2655 private: 2656 VkImportMemoryWin32HandleInfoNV m_struct; 2657 const VkImportMemoryWin32HandleInfoNV* m_origStructAddr; 2658 uint32_t m_indent; 2659 const char m_dummy_prefix; 2660 void display_struct_members(); 2661 2662 }; 2663 2664 2665 //class declaration 2666 class vkinstancecreateinfo_struct_wrapper 2667 { 2668 public: 2669 vkinstancecreateinfo_struct_wrapper(); 2670 vkinstancecreateinfo_struct_wrapper(VkInstanceCreateInfo* pInStruct); 2671 vkinstancecreateinfo_struct_wrapper(const VkInstanceCreateInfo* pInStruct); 2672 2673 virtual ~vkinstancecreateinfo_struct_wrapper(); 2674 2675 void display_txt(); 2676 void display_single_txt(); 2677 void display_full_txt(); 2678 2679 void set_indent(uint32_t indent) { m_indent = indent; } 2680 VkStructureType get_sType() { return m_struct.sType; } 2681 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2682 const void* get_pNext() { return m_struct.pNext; } 2683 VkInstanceCreateFlags get_flags() { return m_struct.flags; } 2684 void set_flags(VkInstanceCreateFlags inValue) { m_struct.flags = inValue; } 2685 const VkApplicationInfo* get_pApplicationInfo() { return m_struct.pApplicationInfo; } 2686 uint32_t get_enabledLayerCount() { return m_struct.enabledLayerCount; } 2687 void set_enabledLayerCount(uint32_t inValue) { m_struct.enabledLayerCount = inValue; } 2688 uint32_t get_enabledExtensionCount() { return m_struct.enabledExtensionCount; } 2689 void set_enabledExtensionCount(uint32_t inValue) { m_struct.enabledExtensionCount = inValue; } 2690 2691 2692 private: 2693 VkInstanceCreateInfo m_struct; 2694 const VkInstanceCreateInfo* m_origStructAddr; 2695 uint32_t m_indent; 2696 const char m_dummy_prefix; 2697 void display_struct_members(); 2698 2699 }; 2700 2701 2702 //class declaration 2703 class vklayerproperties_struct_wrapper 2704 { 2705 public: 2706 vklayerproperties_struct_wrapper(); 2707 vklayerproperties_struct_wrapper(VkLayerProperties* pInStruct); 2708 vklayerproperties_struct_wrapper(const VkLayerProperties* pInStruct); 2709 2710 virtual ~vklayerproperties_struct_wrapper(); 2711 2712 void display_txt(); 2713 void display_single_txt(); 2714 void display_full_txt(); 2715 2716 void set_indent(uint32_t indent) { m_indent = indent; } 2717 uint32_t get_specVersion() { return m_struct.specVersion; } 2718 void set_specVersion(uint32_t inValue) { m_struct.specVersion = inValue; } 2719 uint32_t get_implementationVersion() { return m_struct.implementationVersion; } 2720 void set_implementationVersion(uint32_t inValue) { m_struct.implementationVersion = inValue; } 2721 2722 2723 private: 2724 VkLayerProperties m_struct; 2725 const VkLayerProperties* m_origStructAddr; 2726 uint32_t m_indent; 2727 const char m_dummy_prefix; 2728 void display_struct_members(); 2729 2730 }; 2731 2732 2733 //class declaration 2734 class vkmappedmemoryrange_struct_wrapper 2735 { 2736 public: 2737 vkmappedmemoryrange_struct_wrapper(); 2738 vkmappedmemoryrange_struct_wrapper(VkMappedMemoryRange* pInStruct); 2739 vkmappedmemoryrange_struct_wrapper(const VkMappedMemoryRange* pInStruct); 2740 2741 virtual ~vkmappedmemoryrange_struct_wrapper(); 2742 2743 void display_txt(); 2744 void display_single_txt(); 2745 void display_full_txt(); 2746 2747 void set_indent(uint32_t indent) { m_indent = indent; } 2748 VkStructureType get_sType() { return m_struct.sType; } 2749 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2750 const void* get_pNext() { return m_struct.pNext; } 2751 VkDeviceMemory get_memory() { return m_struct.memory; } 2752 void set_memory(VkDeviceMemory inValue) { m_struct.memory = inValue; } 2753 VkDeviceSize get_offset() { return m_struct.offset; } 2754 void set_offset(VkDeviceSize inValue) { m_struct.offset = inValue; } 2755 VkDeviceSize get_size() { return m_struct.size; } 2756 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 2757 2758 2759 private: 2760 VkMappedMemoryRange m_struct; 2761 const VkMappedMemoryRange* m_origStructAddr; 2762 uint32_t m_indent; 2763 const char m_dummy_prefix; 2764 void display_struct_members(); 2765 2766 }; 2767 2768 2769 //class declaration 2770 class vkmemoryallocateinfo_struct_wrapper 2771 { 2772 public: 2773 vkmemoryallocateinfo_struct_wrapper(); 2774 vkmemoryallocateinfo_struct_wrapper(VkMemoryAllocateInfo* pInStruct); 2775 vkmemoryallocateinfo_struct_wrapper(const VkMemoryAllocateInfo* pInStruct); 2776 2777 virtual ~vkmemoryallocateinfo_struct_wrapper(); 2778 2779 void display_txt(); 2780 void display_single_txt(); 2781 void display_full_txt(); 2782 2783 void set_indent(uint32_t indent) { m_indent = indent; } 2784 VkStructureType get_sType() { return m_struct.sType; } 2785 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2786 const void* get_pNext() { return m_struct.pNext; } 2787 VkDeviceSize get_allocationSize() { return m_struct.allocationSize; } 2788 void set_allocationSize(VkDeviceSize inValue) { m_struct.allocationSize = inValue; } 2789 uint32_t get_memoryTypeIndex() { return m_struct.memoryTypeIndex; } 2790 void set_memoryTypeIndex(uint32_t inValue) { m_struct.memoryTypeIndex = inValue; } 2791 2792 2793 private: 2794 VkMemoryAllocateInfo m_struct; 2795 const VkMemoryAllocateInfo* m_origStructAddr; 2796 uint32_t m_indent; 2797 const char m_dummy_prefix; 2798 void display_struct_members(); 2799 2800 }; 2801 2802 2803 //class declaration 2804 class vkmemorybarrier_struct_wrapper 2805 { 2806 public: 2807 vkmemorybarrier_struct_wrapper(); 2808 vkmemorybarrier_struct_wrapper(VkMemoryBarrier* pInStruct); 2809 vkmemorybarrier_struct_wrapper(const VkMemoryBarrier* pInStruct); 2810 2811 virtual ~vkmemorybarrier_struct_wrapper(); 2812 2813 void display_txt(); 2814 void display_single_txt(); 2815 void display_full_txt(); 2816 2817 void set_indent(uint32_t indent) { m_indent = indent; } 2818 VkStructureType get_sType() { return m_struct.sType; } 2819 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2820 const void* get_pNext() { return m_struct.pNext; } 2821 VkAccessFlags get_srcAccessMask() { return m_struct.srcAccessMask; } 2822 void set_srcAccessMask(VkAccessFlags inValue) { m_struct.srcAccessMask = inValue; } 2823 VkAccessFlags get_dstAccessMask() { return m_struct.dstAccessMask; } 2824 void set_dstAccessMask(VkAccessFlags inValue) { m_struct.dstAccessMask = inValue; } 2825 2826 2827 private: 2828 VkMemoryBarrier m_struct; 2829 const VkMemoryBarrier* m_origStructAddr; 2830 uint32_t m_indent; 2831 const char m_dummy_prefix; 2832 void display_struct_members(); 2833 2834 }; 2835 2836 2837 //class declaration 2838 class vkmemoryheap_struct_wrapper 2839 { 2840 public: 2841 vkmemoryheap_struct_wrapper(); 2842 vkmemoryheap_struct_wrapper(VkMemoryHeap* pInStruct); 2843 vkmemoryheap_struct_wrapper(const VkMemoryHeap* pInStruct); 2844 2845 virtual ~vkmemoryheap_struct_wrapper(); 2846 2847 void display_txt(); 2848 void display_single_txt(); 2849 void display_full_txt(); 2850 2851 void set_indent(uint32_t indent) { m_indent = indent; } 2852 VkDeviceSize get_size() { return m_struct.size; } 2853 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 2854 VkMemoryHeapFlags get_flags() { return m_struct.flags; } 2855 void set_flags(VkMemoryHeapFlags inValue) { m_struct.flags = inValue; } 2856 2857 2858 private: 2859 VkMemoryHeap m_struct; 2860 const VkMemoryHeap* m_origStructAddr; 2861 uint32_t m_indent; 2862 const char m_dummy_prefix; 2863 void display_struct_members(); 2864 2865 }; 2866 2867 2868 //class declaration 2869 class vkmemoryrequirements_struct_wrapper 2870 { 2871 public: 2872 vkmemoryrequirements_struct_wrapper(); 2873 vkmemoryrequirements_struct_wrapper(VkMemoryRequirements* pInStruct); 2874 vkmemoryrequirements_struct_wrapper(const VkMemoryRequirements* pInStruct); 2875 2876 virtual ~vkmemoryrequirements_struct_wrapper(); 2877 2878 void display_txt(); 2879 void display_single_txt(); 2880 void display_full_txt(); 2881 2882 void set_indent(uint32_t indent) { m_indent = indent; } 2883 VkDeviceSize get_size() { return m_struct.size; } 2884 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 2885 VkDeviceSize get_alignment() { return m_struct.alignment; } 2886 void set_alignment(VkDeviceSize inValue) { m_struct.alignment = inValue; } 2887 uint32_t get_memoryTypeBits() { return m_struct.memoryTypeBits; } 2888 void set_memoryTypeBits(uint32_t inValue) { m_struct.memoryTypeBits = inValue; } 2889 2890 2891 private: 2892 VkMemoryRequirements m_struct; 2893 const VkMemoryRequirements* m_origStructAddr; 2894 uint32_t m_indent; 2895 const char m_dummy_prefix; 2896 void display_struct_members(); 2897 2898 }; 2899 2900 2901 //class declaration 2902 class vkmemorytype_struct_wrapper 2903 { 2904 public: 2905 vkmemorytype_struct_wrapper(); 2906 vkmemorytype_struct_wrapper(VkMemoryType* pInStruct); 2907 vkmemorytype_struct_wrapper(const VkMemoryType* pInStruct); 2908 2909 virtual ~vkmemorytype_struct_wrapper(); 2910 2911 void display_txt(); 2912 void display_single_txt(); 2913 void display_full_txt(); 2914 2915 void set_indent(uint32_t indent) { m_indent = indent; } 2916 VkMemoryPropertyFlags get_propertyFlags() { return m_struct.propertyFlags; } 2917 void set_propertyFlags(VkMemoryPropertyFlags inValue) { m_struct.propertyFlags = inValue; } 2918 uint32_t get_heapIndex() { return m_struct.heapIndex; } 2919 void set_heapIndex(uint32_t inValue) { m_struct.heapIndex = inValue; } 2920 2921 2922 private: 2923 VkMemoryType m_struct; 2924 const VkMemoryType* m_origStructAddr; 2925 uint32_t m_indent; 2926 const char m_dummy_prefix; 2927 void display_struct_members(); 2928 2929 }; 2930 2931 2932 //class declaration 2933 class vkmirsurfacecreateinfokhr_struct_wrapper 2934 { 2935 public: 2936 vkmirsurfacecreateinfokhr_struct_wrapper(); 2937 vkmirsurfacecreateinfokhr_struct_wrapper(VkMirSurfaceCreateInfoKHR* pInStruct); 2938 vkmirsurfacecreateinfokhr_struct_wrapper(const VkMirSurfaceCreateInfoKHR* pInStruct); 2939 2940 virtual ~vkmirsurfacecreateinfokhr_struct_wrapper(); 2941 2942 void display_txt(); 2943 void display_single_txt(); 2944 void display_full_txt(); 2945 2946 void set_indent(uint32_t indent) { m_indent = indent; } 2947 VkStructureType get_sType() { return m_struct.sType; } 2948 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 2949 const void* get_pNext() { return m_struct.pNext; } 2950 VkMirSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 2951 void set_flags(VkMirSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 2952 MirConnection* get_connection() { return m_struct.connection; } 2953 void set_connection(MirConnection* inValue) { m_struct.connection = inValue; } 2954 MirSurface* get_mirSurface() { return m_struct.mirSurface; } 2955 void set_mirSurface(MirSurface* inValue) { m_struct.mirSurface = inValue; } 2956 2957 2958 private: 2959 VkMirSurfaceCreateInfoKHR m_struct; 2960 const VkMirSurfaceCreateInfoKHR* m_origStructAddr; 2961 uint32_t m_indent; 2962 const char m_dummy_prefix; 2963 void display_struct_members(); 2964 2965 }; 2966 2967 2968 //class declaration 2969 class vkoffset2d_struct_wrapper 2970 { 2971 public: 2972 vkoffset2d_struct_wrapper(); 2973 vkoffset2d_struct_wrapper(VkOffset2D* pInStruct); 2974 vkoffset2d_struct_wrapper(const VkOffset2D* pInStruct); 2975 2976 virtual ~vkoffset2d_struct_wrapper(); 2977 2978 void display_txt(); 2979 void display_single_txt(); 2980 void display_full_txt(); 2981 2982 void set_indent(uint32_t indent) { m_indent = indent; } 2983 int32_t get_x() { return m_struct.x; } 2984 void set_x(int32_t inValue) { m_struct.x = inValue; } 2985 int32_t get_y() { return m_struct.y; } 2986 void set_y(int32_t inValue) { m_struct.y = inValue; } 2987 2988 2989 private: 2990 VkOffset2D m_struct; 2991 const VkOffset2D* m_origStructAddr; 2992 uint32_t m_indent; 2993 const char m_dummy_prefix; 2994 void display_struct_members(); 2995 2996 }; 2997 2998 2999 //class declaration 3000 class vkoffset3d_struct_wrapper 3001 { 3002 public: 3003 vkoffset3d_struct_wrapper(); 3004 vkoffset3d_struct_wrapper(VkOffset3D* pInStruct); 3005 vkoffset3d_struct_wrapper(const VkOffset3D* pInStruct); 3006 3007 virtual ~vkoffset3d_struct_wrapper(); 3008 3009 void display_txt(); 3010 void display_single_txt(); 3011 void display_full_txt(); 3012 3013 void set_indent(uint32_t indent) { m_indent = indent; } 3014 int32_t get_x() { return m_struct.x; } 3015 void set_x(int32_t inValue) { m_struct.x = inValue; } 3016 int32_t get_y() { return m_struct.y; } 3017 void set_y(int32_t inValue) { m_struct.y = inValue; } 3018 int32_t get_z() { return m_struct.z; } 3019 void set_z(int32_t inValue) { m_struct.z = inValue; } 3020 3021 3022 private: 3023 VkOffset3D m_struct; 3024 const VkOffset3D* m_origStructAddr; 3025 uint32_t m_indent; 3026 const char m_dummy_prefix; 3027 void display_struct_members(); 3028 3029 }; 3030 3031 3032 //class declaration 3033 class vkphysicaldevicefeatures_struct_wrapper 3034 { 3035 public: 3036 vkphysicaldevicefeatures_struct_wrapper(); 3037 vkphysicaldevicefeatures_struct_wrapper(VkPhysicalDeviceFeatures* pInStruct); 3038 vkphysicaldevicefeatures_struct_wrapper(const VkPhysicalDeviceFeatures* pInStruct); 3039 3040 virtual ~vkphysicaldevicefeatures_struct_wrapper(); 3041 3042 void display_txt(); 3043 void display_single_txt(); 3044 void display_full_txt(); 3045 3046 void set_indent(uint32_t indent) { m_indent = indent; } 3047 VkBool32 get_robustBufferAccess() { return m_struct.robustBufferAccess; } 3048 void set_robustBufferAccess(VkBool32 inValue) { m_struct.robustBufferAccess = inValue; } 3049 VkBool32 get_fullDrawIndexUint32() { return m_struct.fullDrawIndexUint32; } 3050 void set_fullDrawIndexUint32(VkBool32 inValue) { m_struct.fullDrawIndexUint32 = inValue; } 3051 VkBool32 get_imageCubeArray() { return m_struct.imageCubeArray; } 3052 void set_imageCubeArray(VkBool32 inValue) { m_struct.imageCubeArray = inValue; } 3053 VkBool32 get_independentBlend() { return m_struct.independentBlend; } 3054 void set_independentBlend(VkBool32 inValue) { m_struct.independentBlend = inValue; } 3055 VkBool32 get_geometryShader() { return m_struct.geometryShader; } 3056 void set_geometryShader(VkBool32 inValue) { m_struct.geometryShader = inValue; } 3057 VkBool32 get_tessellationShader() { return m_struct.tessellationShader; } 3058 void set_tessellationShader(VkBool32 inValue) { m_struct.tessellationShader = inValue; } 3059 VkBool32 get_sampleRateShading() { return m_struct.sampleRateShading; } 3060 void set_sampleRateShading(VkBool32 inValue) { m_struct.sampleRateShading = inValue; } 3061 VkBool32 get_dualSrcBlend() { return m_struct.dualSrcBlend; } 3062 void set_dualSrcBlend(VkBool32 inValue) { m_struct.dualSrcBlend = inValue; } 3063 VkBool32 get_logicOp() { return m_struct.logicOp; } 3064 void set_logicOp(VkBool32 inValue) { m_struct.logicOp = inValue; } 3065 VkBool32 get_multiDrawIndirect() { return m_struct.multiDrawIndirect; } 3066 void set_multiDrawIndirect(VkBool32 inValue) { m_struct.multiDrawIndirect = inValue; } 3067 VkBool32 get_drawIndirectFirstInstance() { return m_struct.drawIndirectFirstInstance; } 3068 void set_drawIndirectFirstInstance(VkBool32 inValue) { m_struct.drawIndirectFirstInstance = inValue; } 3069 VkBool32 get_depthClamp() { return m_struct.depthClamp; } 3070 void set_depthClamp(VkBool32 inValue) { m_struct.depthClamp = inValue; } 3071 VkBool32 get_depthBiasClamp() { return m_struct.depthBiasClamp; } 3072 void set_depthBiasClamp(VkBool32 inValue) { m_struct.depthBiasClamp = inValue; } 3073 VkBool32 get_fillModeNonSolid() { return m_struct.fillModeNonSolid; } 3074 void set_fillModeNonSolid(VkBool32 inValue) { m_struct.fillModeNonSolid = inValue; } 3075 VkBool32 get_depthBounds() { return m_struct.depthBounds; } 3076 void set_depthBounds(VkBool32 inValue) { m_struct.depthBounds = inValue; } 3077 VkBool32 get_wideLines() { return m_struct.wideLines; } 3078 void set_wideLines(VkBool32 inValue) { m_struct.wideLines = inValue; } 3079 VkBool32 get_largePoints() { return m_struct.largePoints; } 3080 void set_largePoints(VkBool32 inValue) { m_struct.largePoints = inValue; } 3081 VkBool32 get_alphaToOne() { return m_struct.alphaToOne; } 3082 void set_alphaToOne(VkBool32 inValue) { m_struct.alphaToOne = inValue; } 3083 VkBool32 get_multiViewport() { return m_struct.multiViewport; } 3084 void set_multiViewport(VkBool32 inValue) { m_struct.multiViewport = inValue; } 3085 VkBool32 get_samplerAnisotropy() { return m_struct.samplerAnisotropy; } 3086 void set_samplerAnisotropy(VkBool32 inValue) { m_struct.samplerAnisotropy = inValue; } 3087 VkBool32 get_textureCompressionETC2() { return m_struct.textureCompressionETC2; } 3088 void set_textureCompressionETC2(VkBool32 inValue) { m_struct.textureCompressionETC2 = inValue; } 3089 VkBool32 get_textureCompressionASTC_LDR() { return m_struct.textureCompressionASTC_LDR; } 3090 void set_textureCompressionASTC_LDR(VkBool32 inValue) { m_struct.textureCompressionASTC_LDR = inValue; } 3091 VkBool32 get_textureCompressionBC() { return m_struct.textureCompressionBC; } 3092 void set_textureCompressionBC(VkBool32 inValue) { m_struct.textureCompressionBC = inValue; } 3093 VkBool32 get_occlusionQueryPrecise() { return m_struct.occlusionQueryPrecise; } 3094 void set_occlusionQueryPrecise(VkBool32 inValue) { m_struct.occlusionQueryPrecise = inValue; } 3095 VkBool32 get_pipelineStatisticsQuery() { return m_struct.pipelineStatisticsQuery; } 3096 void set_pipelineStatisticsQuery(VkBool32 inValue) { m_struct.pipelineStatisticsQuery = inValue; } 3097 VkBool32 get_vertexPipelineStoresAndAtomics() { return m_struct.vertexPipelineStoresAndAtomics; } 3098 void set_vertexPipelineStoresAndAtomics(VkBool32 inValue) { m_struct.vertexPipelineStoresAndAtomics = inValue; } 3099 VkBool32 get_fragmentStoresAndAtomics() { return m_struct.fragmentStoresAndAtomics; } 3100 void set_fragmentStoresAndAtomics(VkBool32 inValue) { m_struct.fragmentStoresAndAtomics = inValue; } 3101 VkBool32 get_shaderTessellationAndGeometryPointSize() { return m_struct.shaderTessellationAndGeometryPointSize; } 3102 void set_shaderTessellationAndGeometryPointSize(VkBool32 inValue) { m_struct.shaderTessellationAndGeometryPointSize = inValue; } 3103 VkBool32 get_shaderImageGatherExtended() { return m_struct.shaderImageGatherExtended; } 3104 void set_shaderImageGatherExtended(VkBool32 inValue) { m_struct.shaderImageGatherExtended = inValue; } 3105 VkBool32 get_shaderStorageImageExtendedFormats() { return m_struct.shaderStorageImageExtendedFormats; } 3106 void set_shaderStorageImageExtendedFormats(VkBool32 inValue) { m_struct.shaderStorageImageExtendedFormats = inValue; } 3107 VkBool32 get_shaderStorageImageMultisample() { return m_struct.shaderStorageImageMultisample; } 3108 void set_shaderStorageImageMultisample(VkBool32 inValue) { m_struct.shaderStorageImageMultisample = inValue; } 3109 VkBool32 get_shaderStorageImageReadWithoutFormat() { return m_struct.shaderStorageImageReadWithoutFormat; } 3110 void set_shaderStorageImageReadWithoutFormat(VkBool32 inValue) { m_struct.shaderStorageImageReadWithoutFormat = inValue; } 3111 VkBool32 get_shaderStorageImageWriteWithoutFormat() { return m_struct.shaderStorageImageWriteWithoutFormat; } 3112 void set_shaderStorageImageWriteWithoutFormat(VkBool32 inValue) { m_struct.shaderStorageImageWriteWithoutFormat = inValue; } 3113 VkBool32 get_shaderUniformBufferArrayDynamicIndexing() { return m_struct.shaderUniformBufferArrayDynamicIndexing; } 3114 void set_shaderUniformBufferArrayDynamicIndexing(VkBool32 inValue) { m_struct.shaderUniformBufferArrayDynamicIndexing = inValue; } 3115 VkBool32 get_shaderSampledImageArrayDynamicIndexing() { return m_struct.shaderSampledImageArrayDynamicIndexing; } 3116 void set_shaderSampledImageArrayDynamicIndexing(VkBool32 inValue) { m_struct.shaderSampledImageArrayDynamicIndexing = inValue; } 3117 VkBool32 get_shaderStorageBufferArrayDynamicIndexing() { return m_struct.shaderStorageBufferArrayDynamicIndexing; } 3118 void set_shaderStorageBufferArrayDynamicIndexing(VkBool32 inValue) { m_struct.shaderStorageBufferArrayDynamicIndexing = inValue; } 3119 VkBool32 get_shaderStorageImageArrayDynamicIndexing() { return m_struct.shaderStorageImageArrayDynamicIndexing; } 3120 void set_shaderStorageImageArrayDynamicIndexing(VkBool32 inValue) { m_struct.shaderStorageImageArrayDynamicIndexing = inValue; } 3121 VkBool32 get_shaderClipDistance() { return m_struct.shaderClipDistance; } 3122 void set_shaderClipDistance(VkBool32 inValue) { m_struct.shaderClipDistance = inValue; } 3123 VkBool32 get_shaderCullDistance() { return m_struct.shaderCullDistance; } 3124 void set_shaderCullDistance(VkBool32 inValue) { m_struct.shaderCullDistance = inValue; } 3125 VkBool32 get_shaderFloat64() { return m_struct.shaderFloat64; } 3126 void set_shaderFloat64(VkBool32 inValue) { m_struct.shaderFloat64 = inValue; } 3127 VkBool32 get_shaderInt64() { return m_struct.shaderInt64; } 3128 void set_shaderInt64(VkBool32 inValue) { m_struct.shaderInt64 = inValue; } 3129 VkBool32 get_shaderInt16() { return m_struct.shaderInt16; } 3130 void set_shaderInt16(VkBool32 inValue) { m_struct.shaderInt16 = inValue; } 3131 VkBool32 get_shaderResourceResidency() { return m_struct.shaderResourceResidency; } 3132 void set_shaderResourceResidency(VkBool32 inValue) { m_struct.shaderResourceResidency = inValue; } 3133 VkBool32 get_shaderResourceMinLod() { return m_struct.shaderResourceMinLod; } 3134 void set_shaderResourceMinLod(VkBool32 inValue) { m_struct.shaderResourceMinLod = inValue; } 3135 VkBool32 get_sparseBinding() { return m_struct.sparseBinding; } 3136 void set_sparseBinding(VkBool32 inValue) { m_struct.sparseBinding = inValue; } 3137 VkBool32 get_sparseResidencyBuffer() { return m_struct.sparseResidencyBuffer; } 3138 void set_sparseResidencyBuffer(VkBool32 inValue) { m_struct.sparseResidencyBuffer = inValue; } 3139 VkBool32 get_sparseResidencyImage2D() { return m_struct.sparseResidencyImage2D; } 3140 void set_sparseResidencyImage2D(VkBool32 inValue) { m_struct.sparseResidencyImage2D = inValue; } 3141 VkBool32 get_sparseResidencyImage3D() { return m_struct.sparseResidencyImage3D; } 3142 void set_sparseResidencyImage3D(VkBool32 inValue) { m_struct.sparseResidencyImage3D = inValue; } 3143 VkBool32 get_sparseResidency2Samples() { return m_struct.sparseResidency2Samples; } 3144 void set_sparseResidency2Samples(VkBool32 inValue) { m_struct.sparseResidency2Samples = inValue; } 3145 VkBool32 get_sparseResidency4Samples() { return m_struct.sparseResidency4Samples; } 3146 void set_sparseResidency4Samples(VkBool32 inValue) { m_struct.sparseResidency4Samples = inValue; } 3147 VkBool32 get_sparseResidency8Samples() { return m_struct.sparseResidency8Samples; } 3148 void set_sparseResidency8Samples(VkBool32 inValue) { m_struct.sparseResidency8Samples = inValue; } 3149 VkBool32 get_sparseResidency16Samples() { return m_struct.sparseResidency16Samples; } 3150 void set_sparseResidency16Samples(VkBool32 inValue) { m_struct.sparseResidency16Samples = inValue; } 3151 VkBool32 get_sparseResidencyAliased() { return m_struct.sparseResidencyAliased; } 3152 void set_sparseResidencyAliased(VkBool32 inValue) { m_struct.sparseResidencyAliased = inValue; } 3153 VkBool32 get_variableMultisampleRate() { return m_struct.variableMultisampleRate; } 3154 void set_variableMultisampleRate(VkBool32 inValue) { m_struct.variableMultisampleRate = inValue; } 3155 VkBool32 get_inheritedQueries() { return m_struct.inheritedQueries; } 3156 void set_inheritedQueries(VkBool32 inValue) { m_struct.inheritedQueries = inValue; } 3157 3158 3159 private: 3160 VkPhysicalDeviceFeatures m_struct; 3161 const VkPhysicalDeviceFeatures* m_origStructAddr; 3162 uint32_t m_indent; 3163 const char m_dummy_prefix; 3164 void display_struct_members(); 3165 3166 }; 3167 3168 3169 //class declaration 3170 class vkphysicaldevicelimits_struct_wrapper 3171 { 3172 public: 3173 vkphysicaldevicelimits_struct_wrapper(); 3174 vkphysicaldevicelimits_struct_wrapper(VkPhysicalDeviceLimits* pInStruct); 3175 vkphysicaldevicelimits_struct_wrapper(const VkPhysicalDeviceLimits* pInStruct); 3176 3177 virtual ~vkphysicaldevicelimits_struct_wrapper(); 3178 3179 void display_txt(); 3180 void display_single_txt(); 3181 void display_full_txt(); 3182 3183 void set_indent(uint32_t indent) { m_indent = indent; } 3184 uint32_t get_maxImageDimension1D() { return m_struct.maxImageDimension1D; } 3185 void set_maxImageDimension1D(uint32_t inValue) { m_struct.maxImageDimension1D = inValue; } 3186 uint32_t get_maxImageDimension2D() { return m_struct.maxImageDimension2D; } 3187 void set_maxImageDimension2D(uint32_t inValue) { m_struct.maxImageDimension2D = inValue; } 3188 uint32_t get_maxImageDimension3D() { return m_struct.maxImageDimension3D; } 3189 void set_maxImageDimension3D(uint32_t inValue) { m_struct.maxImageDimension3D = inValue; } 3190 uint32_t get_maxImageDimensionCube() { return m_struct.maxImageDimensionCube; } 3191 void set_maxImageDimensionCube(uint32_t inValue) { m_struct.maxImageDimensionCube = inValue; } 3192 uint32_t get_maxImageArrayLayers() { return m_struct.maxImageArrayLayers; } 3193 void set_maxImageArrayLayers(uint32_t inValue) { m_struct.maxImageArrayLayers = inValue; } 3194 uint32_t get_maxTexelBufferElements() { return m_struct.maxTexelBufferElements; } 3195 void set_maxTexelBufferElements(uint32_t inValue) { m_struct.maxTexelBufferElements = inValue; } 3196 uint32_t get_maxUniformBufferRange() { return m_struct.maxUniformBufferRange; } 3197 void set_maxUniformBufferRange(uint32_t inValue) { m_struct.maxUniformBufferRange = inValue; } 3198 uint32_t get_maxStorageBufferRange() { return m_struct.maxStorageBufferRange; } 3199 void set_maxStorageBufferRange(uint32_t inValue) { m_struct.maxStorageBufferRange = inValue; } 3200 uint32_t get_maxPushConstantsSize() { return m_struct.maxPushConstantsSize; } 3201 void set_maxPushConstantsSize(uint32_t inValue) { m_struct.maxPushConstantsSize = inValue; } 3202 uint32_t get_maxMemoryAllocationCount() { return m_struct.maxMemoryAllocationCount; } 3203 void set_maxMemoryAllocationCount(uint32_t inValue) { m_struct.maxMemoryAllocationCount = inValue; } 3204 uint32_t get_maxSamplerAllocationCount() { return m_struct.maxSamplerAllocationCount; } 3205 void set_maxSamplerAllocationCount(uint32_t inValue) { m_struct.maxSamplerAllocationCount = inValue; } 3206 VkDeviceSize get_bufferImageGranularity() { return m_struct.bufferImageGranularity; } 3207 void set_bufferImageGranularity(VkDeviceSize inValue) { m_struct.bufferImageGranularity = inValue; } 3208 VkDeviceSize get_sparseAddressSpaceSize() { return m_struct.sparseAddressSpaceSize; } 3209 void set_sparseAddressSpaceSize(VkDeviceSize inValue) { m_struct.sparseAddressSpaceSize = inValue; } 3210 uint32_t get_maxBoundDescriptorSets() { return m_struct.maxBoundDescriptorSets; } 3211 void set_maxBoundDescriptorSets(uint32_t inValue) { m_struct.maxBoundDescriptorSets = inValue; } 3212 uint32_t get_maxPerStageDescriptorSamplers() { return m_struct.maxPerStageDescriptorSamplers; } 3213 void set_maxPerStageDescriptorSamplers(uint32_t inValue) { m_struct.maxPerStageDescriptorSamplers = inValue; } 3214 uint32_t get_maxPerStageDescriptorUniformBuffers() { return m_struct.maxPerStageDescriptorUniformBuffers; } 3215 void set_maxPerStageDescriptorUniformBuffers(uint32_t inValue) { m_struct.maxPerStageDescriptorUniformBuffers = inValue; } 3216 uint32_t get_maxPerStageDescriptorStorageBuffers() { return m_struct.maxPerStageDescriptorStorageBuffers; } 3217 void set_maxPerStageDescriptorStorageBuffers(uint32_t inValue) { m_struct.maxPerStageDescriptorStorageBuffers = inValue; } 3218 uint32_t get_maxPerStageDescriptorSampledImages() { return m_struct.maxPerStageDescriptorSampledImages; } 3219 void set_maxPerStageDescriptorSampledImages(uint32_t inValue) { m_struct.maxPerStageDescriptorSampledImages = inValue; } 3220 uint32_t get_maxPerStageDescriptorStorageImages() { return m_struct.maxPerStageDescriptorStorageImages; } 3221 void set_maxPerStageDescriptorStorageImages(uint32_t inValue) { m_struct.maxPerStageDescriptorStorageImages = inValue; } 3222 uint32_t get_maxPerStageDescriptorInputAttachments() { return m_struct.maxPerStageDescriptorInputAttachments; } 3223 void set_maxPerStageDescriptorInputAttachments(uint32_t inValue) { m_struct.maxPerStageDescriptorInputAttachments = inValue; } 3224 uint32_t get_maxPerStageResources() { return m_struct.maxPerStageResources; } 3225 void set_maxPerStageResources(uint32_t inValue) { m_struct.maxPerStageResources = inValue; } 3226 uint32_t get_maxDescriptorSetSamplers() { return m_struct.maxDescriptorSetSamplers; } 3227 void set_maxDescriptorSetSamplers(uint32_t inValue) { m_struct.maxDescriptorSetSamplers = inValue; } 3228 uint32_t get_maxDescriptorSetUniformBuffers() { return m_struct.maxDescriptorSetUniformBuffers; } 3229 void set_maxDescriptorSetUniformBuffers(uint32_t inValue) { m_struct.maxDescriptorSetUniformBuffers = inValue; } 3230 uint32_t get_maxDescriptorSetUniformBuffersDynamic() { return m_struct.maxDescriptorSetUniformBuffersDynamic; } 3231 void set_maxDescriptorSetUniformBuffersDynamic(uint32_t inValue) { m_struct.maxDescriptorSetUniformBuffersDynamic = inValue; } 3232 uint32_t get_maxDescriptorSetStorageBuffers() { return m_struct.maxDescriptorSetStorageBuffers; } 3233 void set_maxDescriptorSetStorageBuffers(uint32_t inValue) { m_struct.maxDescriptorSetStorageBuffers = inValue; } 3234 uint32_t get_maxDescriptorSetStorageBuffersDynamic() { return m_struct.maxDescriptorSetStorageBuffersDynamic; } 3235 void set_maxDescriptorSetStorageBuffersDynamic(uint32_t inValue) { m_struct.maxDescriptorSetStorageBuffersDynamic = inValue; } 3236 uint32_t get_maxDescriptorSetSampledImages() { return m_struct.maxDescriptorSetSampledImages; } 3237 void set_maxDescriptorSetSampledImages(uint32_t inValue) { m_struct.maxDescriptorSetSampledImages = inValue; } 3238 uint32_t get_maxDescriptorSetStorageImages() { return m_struct.maxDescriptorSetStorageImages; } 3239 void set_maxDescriptorSetStorageImages(uint32_t inValue) { m_struct.maxDescriptorSetStorageImages = inValue; } 3240 uint32_t get_maxDescriptorSetInputAttachments() { return m_struct.maxDescriptorSetInputAttachments; } 3241 void set_maxDescriptorSetInputAttachments(uint32_t inValue) { m_struct.maxDescriptorSetInputAttachments = inValue; } 3242 uint32_t get_maxVertexInputAttributes() { return m_struct.maxVertexInputAttributes; } 3243 void set_maxVertexInputAttributes(uint32_t inValue) { m_struct.maxVertexInputAttributes = inValue; } 3244 uint32_t get_maxVertexInputBindings() { return m_struct.maxVertexInputBindings; } 3245 void set_maxVertexInputBindings(uint32_t inValue) { m_struct.maxVertexInputBindings = inValue; } 3246 uint32_t get_maxVertexInputAttributeOffset() { return m_struct.maxVertexInputAttributeOffset; } 3247 void set_maxVertexInputAttributeOffset(uint32_t inValue) { m_struct.maxVertexInputAttributeOffset = inValue; } 3248 uint32_t get_maxVertexInputBindingStride() { return m_struct.maxVertexInputBindingStride; } 3249 void set_maxVertexInputBindingStride(uint32_t inValue) { m_struct.maxVertexInputBindingStride = inValue; } 3250 uint32_t get_maxVertexOutputComponents() { return m_struct.maxVertexOutputComponents; } 3251 void set_maxVertexOutputComponents(uint32_t inValue) { m_struct.maxVertexOutputComponents = inValue; } 3252 uint32_t get_maxTessellationGenerationLevel() { return m_struct.maxTessellationGenerationLevel; } 3253 void set_maxTessellationGenerationLevel(uint32_t inValue) { m_struct.maxTessellationGenerationLevel = inValue; } 3254 uint32_t get_maxTessellationPatchSize() { return m_struct.maxTessellationPatchSize; } 3255 void set_maxTessellationPatchSize(uint32_t inValue) { m_struct.maxTessellationPatchSize = inValue; } 3256 uint32_t get_maxTessellationControlPerVertexInputComponents() { return m_struct.maxTessellationControlPerVertexInputComponents; } 3257 void set_maxTessellationControlPerVertexInputComponents(uint32_t inValue) { m_struct.maxTessellationControlPerVertexInputComponents = inValue; } 3258 uint32_t get_maxTessellationControlPerVertexOutputComponents() { return m_struct.maxTessellationControlPerVertexOutputComponents; } 3259 void set_maxTessellationControlPerVertexOutputComponents(uint32_t inValue) { m_struct.maxTessellationControlPerVertexOutputComponents = inValue; } 3260 uint32_t get_maxTessellationControlPerPatchOutputComponents() { return m_struct.maxTessellationControlPerPatchOutputComponents; } 3261 void set_maxTessellationControlPerPatchOutputComponents(uint32_t inValue) { m_struct.maxTessellationControlPerPatchOutputComponents = inValue; } 3262 uint32_t get_maxTessellationControlTotalOutputComponents() { return m_struct.maxTessellationControlTotalOutputComponents; } 3263 void set_maxTessellationControlTotalOutputComponents(uint32_t inValue) { m_struct.maxTessellationControlTotalOutputComponents = inValue; } 3264 uint32_t get_maxTessellationEvaluationInputComponents() { return m_struct.maxTessellationEvaluationInputComponents; } 3265 void set_maxTessellationEvaluationInputComponents(uint32_t inValue) { m_struct.maxTessellationEvaluationInputComponents = inValue; } 3266 uint32_t get_maxTessellationEvaluationOutputComponents() { return m_struct.maxTessellationEvaluationOutputComponents; } 3267 void set_maxTessellationEvaluationOutputComponents(uint32_t inValue) { m_struct.maxTessellationEvaluationOutputComponents = inValue; } 3268 uint32_t get_maxGeometryShaderInvocations() { return m_struct.maxGeometryShaderInvocations; } 3269 void set_maxGeometryShaderInvocations(uint32_t inValue) { m_struct.maxGeometryShaderInvocations = inValue; } 3270 uint32_t get_maxGeometryInputComponents() { return m_struct.maxGeometryInputComponents; } 3271 void set_maxGeometryInputComponents(uint32_t inValue) { m_struct.maxGeometryInputComponents = inValue; } 3272 uint32_t get_maxGeometryOutputComponents() { return m_struct.maxGeometryOutputComponents; } 3273 void set_maxGeometryOutputComponents(uint32_t inValue) { m_struct.maxGeometryOutputComponents = inValue; } 3274 uint32_t get_maxGeometryOutputVertices() { return m_struct.maxGeometryOutputVertices; } 3275 void set_maxGeometryOutputVertices(uint32_t inValue) { m_struct.maxGeometryOutputVertices = inValue; } 3276 uint32_t get_maxGeometryTotalOutputComponents() { return m_struct.maxGeometryTotalOutputComponents; } 3277 void set_maxGeometryTotalOutputComponents(uint32_t inValue) { m_struct.maxGeometryTotalOutputComponents = inValue; } 3278 uint32_t get_maxFragmentInputComponents() { return m_struct.maxFragmentInputComponents; } 3279 void set_maxFragmentInputComponents(uint32_t inValue) { m_struct.maxFragmentInputComponents = inValue; } 3280 uint32_t get_maxFragmentOutputAttachments() { return m_struct.maxFragmentOutputAttachments; } 3281 void set_maxFragmentOutputAttachments(uint32_t inValue) { m_struct.maxFragmentOutputAttachments = inValue; } 3282 uint32_t get_maxFragmentDualSrcAttachments() { return m_struct.maxFragmentDualSrcAttachments; } 3283 void set_maxFragmentDualSrcAttachments(uint32_t inValue) { m_struct.maxFragmentDualSrcAttachments = inValue; } 3284 uint32_t get_maxFragmentCombinedOutputResources() { return m_struct.maxFragmentCombinedOutputResources; } 3285 void set_maxFragmentCombinedOutputResources(uint32_t inValue) { m_struct.maxFragmentCombinedOutputResources = inValue; } 3286 uint32_t get_maxComputeSharedMemorySize() { return m_struct.maxComputeSharedMemorySize; } 3287 void set_maxComputeSharedMemorySize(uint32_t inValue) { m_struct.maxComputeSharedMemorySize = inValue; } 3288 uint32_t get_maxComputeWorkGroupInvocations() { return m_struct.maxComputeWorkGroupInvocations; } 3289 void set_maxComputeWorkGroupInvocations(uint32_t inValue) { m_struct.maxComputeWorkGroupInvocations = inValue; } 3290 uint32_t get_subPixelPrecisionBits() { return m_struct.subPixelPrecisionBits; } 3291 void set_subPixelPrecisionBits(uint32_t inValue) { m_struct.subPixelPrecisionBits = inValue; } 3292 uint32_t get_subTexelPrecisionBits() { return m_struct.subTexelPrecisionBits; } 3293 void set_subTexelPrecisionBits(uint32_t inValue) { m_struct.subTexelPrecisionBits = inValue; } 3294 uint32_t get_mipmapPrecisionBits() { return m_struct.mipmapPrecisionBits; } 3295 void set_mipmapPrecisionBits(uint32_t inValue) { m_struct.mipmapPrecisionBits = inValue; } 3296 uint32_t get_maxDrawIndexedIndexValue() { return m_struct.maxDrawIndexedIndexValue; } 3297 void set_maxDrawIndexedIndexValue(uint32_t inValue) { m_struct.maxDrawIndexedIndexValue = inValue; } 3298 uint32_t get_maxDrawIndirectCount() { return m_struct.maxDrawIndirectCount; } 3299 void set_maxDrawIndirectCount(uint32_t inValue) { m_struct.maxDrawIndirectCount = inValue; } 3300 float get_maxSamplerLodBias() { return m_struct.maxSamplerLodBias; } 3301 void set_maxSamplerLodBias(float inValue) { m_struct.maxSamplerLodBias = inValue; } 3302 float get_maxSamplerAnisotropy() { return m_struct.maxSamplerAnisotropy; } 3303 void set_maxSamplerAnisotropy(float inValue) { m_struct.maxSamplerAnisotropy = inValue; } 3304 uint32_t get_maxViewports() { return m_struct.maxViewports; } 3305 void set_maxViewports(uint32_t inValue) { m_struct.maxViewports = inValue; } 3306 uint32_t get_viewportSubPixelBits() { return m_struct.viewportSubPixelBits; } 3307 void set_viewportSubPixelBits(uint32_t inValue) { m_struct.viewportSubPixelBits = inValue; } 3308 size_t get_minMemoryMapAlignment() { return m_struct.minMemoryMapAlignment; } 3309 void set_minMemoryMapAlignment(size_t inValue) { m_struct.minMemoryMapAlignment = inValue; } 3310 VkDeviceSize get_minTexelBufferOffsetAlignment() { return m_struct.minTexelBufferOffsetAlignment; } 3311 void set_minTexelBufferOffsetAlignment(VkDeviceSize inValue) { m_struct.minTexelBufferOffsetAlignment = inValue; } 3312 VkDeviceSize get_minUniformBufferOffsetAlignment() { return m_struct.minUniformBufferOffsetAlignment; } 3313 void set_minUniformBufferOffsetAlignment(VkDeviceSize inValue) { m_struct.minUniformBufferOffsetAlignment = inValue; } 3314 VkDeviceSize get_minStorageBufferOffsetAlignment() { return m_struct.minStorageBufferOffsetAlignment; } 3315 void set_minStorageBufferOffsetAlignment(VkDeviceSize inValue) { m_struct.minStorageBufferOffsetAlignment = inValue; } 3316 int32_t get_minTexelOffset() { return m_struct.minTexelOffset; } 3317 void set_minTexelOffset(int32_t inValue) { m_struct.minTexelOffset = inValue; } 3318 uint32_t get_maxTexelOffset() { return m_struct.maxTexelOffset; } 3319 void set_maxTexelOffset(uint32_t inValue) { m_struct.maxTexelOffset = inValue; } 3320 int32_t get_minTexelGatherOffset() { return m_struct.minTexelGatherOffset; } 3321 void set_minTexelGatherOffset(int32_t inValue) { m_struct.minTexelGatherOffset = inValue; } 3322 uint32_t get_maxTexelGatherOffset() { return m_struct.maxTexelGatherOffset; } 3323 void set_maxTexelGatherOffset(uint32_t inValue) { m_struct.maxTexelGatherOffset = inValue; } 3324 float get_minInterpolationOffset() { return m_struct.minInterpolationOffset; } 3325 void set_minInterpolationOffset(float inValue) { m_struct.minInterpolationOffset = inValue; } 3326 float get_maxInterpolationOffset() { return m_struct.maxInterpolationOffset; } 3327 void set_maxInterpolationOffset(float inValue) { m_struct.maxInterpolationOffset = inValue; } 3328 uint32_t get_subPixelInterpolationOffsetBits() { return m_struct.subPixelInterpolationOffsetBits; } 3329 void set_subPixelInterpolationOffsetBits(uint32_t inValue) { m_struct.subPixelInterpolationOffsetBits = inValue; } 3330 uint32_t get_maxFramebufferWidth() { return m_struct.maxFramebufferWidth; } 3331 void set_maxFramebufferWidth(uint32_t inValue) { m_struct.maxFramebufferWidth = inValue; } 3332 uint32_t get_maxFramebufferHeight() { return m_struct.maxFramebufferHeight; } 3333 void set_maxFramebufferHeight(uint32_t inValue) { m_struct.maxFramebufferHeight = inValue; } 3334 uint32_t get_maxFramebufferLayers() { return m_struct.maxFramebufferLayers; } 3335 void set_maxFramebufferLayers(uint32_t inValue) { m_struct.maxFramebufferLayers = inValue; } 3336 VkSampleCountFlags get_framebufferColorSampleCounts() { return m_struct.framebufferColorSampleCounts; } 3337 void set_framebufferColorSampleCounts(VkSampleCountFlags inValue) { m_struct.framebufferColorSampleCounts = inValue; } 3338 VkSampleCountFlags get_framebufferDepthSampleCounts() { return m_struct.framebufferDepthSampleCounts; } 3339 void set_framebufferDepthSampleCounts(VkSampleCountFlags inValue) { m_struct.framebufferDepthSampleCounts = inValue; } 3340 VkSampleCountFlags get_framebufferStencilSampleCounts() { return m_struct.framebufferStencilSampleCounts; } 3341 void set_framebufferStencilSampleCounts(VkSampleCountFlags inValue) { m_struct.framebufferStencilSampleCounts = inValue; } 3342 VkSampleCountFlags get_framebufferNoAttachmentsSampleCounts() { return m_struct.framebufferNoAttachmentsSampleCounts; } 3343 void set_framebufferNoAttachmentsSampleCounts(VkSampleCountFlags inValue) { m_struct.framebufferNoAttachmentsSampleCounts = inValue; } 3344 uint32_t get_maxColorAttachments() { return m_struct.maxColorAttachments; } 3345 void set_maxColorAttachments(uint32_t inValue) { m_struct.maxColorAttachments = inValue; } 3346 VkSampleCountFlags get_sampledImageColorSampleCounts() { return m_struct.sampledImageColorSampleCounts; } 3347 void set_sampledImageColorSampleCounts(VkSampleCountFlags inValue) { m_struct.sampledImageColorSampleCounts = inValue; } 3348 VkSampleCountFlags get_sampledImageIntegerSampleCounts() { return m_struct.sampledImageIntegerSampleCounts; } 3349 void set_sampledImageIntegerSampleCounts(VkSampleCountFlags inValue) { m_struct.sampledImageIntegerSampleCounts = inValue; } 3350 VkSampleCountFlags get_sampledImageDepthSampleCounts() { return m_struct.sampledImageDepthSampleCounts; } 3351 void set_sampledImageDepthSampleCounts(VkSampleCountFlags inValue) { m_struct.sampledImageDepthSampleCounts = inValue; } 3352 VkSampleCountFlags get_sampledImageStencilSampleCounts() { return m_struct.sampledImageStencilSampleCounts; } 3353 void set_sampledImageStencilSampleCounts(VkSampleCountFlags inValue) { m_struct.sampledImageStencilSampleCounts = inValue; } 3354 VkSampleCountFlags get_storageImageSampleCounts() { return m_struct.storageImageSampleCounts; } 3355 void set_storageImageSampleCounts(VkSampleCountFlags inValue) { m_struct.storageImageSampleCounts = inValue; } 3356 uint32_t get_maxSampleMaskWords() { return m_struct.maxSampleMaskWords; } 3357 void set_maxSampleMaskWords(uint32_t inValue) { m_struct.maxSampleMaskWords = inValue; } 3358 VkBool32 get_timestampComputeAndGraphics() { return m_struct.timestampComputeAndGraphics; } 3359 void set_timestampComputeAndGraphics(VkBool32 inValue) { m_struct.timestampComputeAndGraphics = inValue; } 3360 float get_timestampPeriod() { return m_struct.timestampPeriod; } 3361 void set_timestampPeriod(float inValue) { m_struct.timestampPeriod = inValue; } 3362 uint32_t get_maxClipDistances() { return m_struct.maxClipDistances; } 3363 void set_maxClipDistances(uint32_t inValue) { m_struct.maxClipDistances = inValue; } 3364 uint32_t get_maxCullDistances() { return m_struct.maxCullDistances; } 3365 void set_maxCullDistances(uint32_t inValue) { m_struct.maxCullDistances = inValue; } 3366 uint32_t get_maxCombinedClipAndCullDistances() { return m_struct.maxCombinedClipAndCullDistances; } 3367 void set_maxCombinedClipAndCullDistances(uint32_t inValue) { m_struct.maxCombinedClipAndCullDistances = inValue; } 3368 uint32_t get_discreteQueuePriorities() { return m_struct.discreteQueuePriorities; } 3369 void set_discreteQueuePriorities(uint32_t inValue) { m_struct.discreteQueuePriorities = inValue; } 3370 float get_pointSizeGranularity() { return m_struct.pointSizeGranularity; } 3371 void set_pointSizeGranularity(float inValue) { m_struct.pointSizeGranularity = inValue; } 3372 float get_lineWidthGranularity() { return m_struct.lineWidthGranularity; } 3373 void set_lineWidthGranularity(float inValue) { m_struct.lineWidthGranularity = inValue; } 3374 VkBool32 get_strictLines() { return m_struct.strictLines; } 3375 void set_strictLines(VkBool32 inValue) { m_struct.strictLines = inValue; } 3376 VkBool32 get_standardSampleLocations() { return m_struct.standardSampleLocations; } 3377 void set_standardSampleLocations(VkBool32 inValue) { m_struct.standardSampleLocations = inValue; } 3378 VkDeviceSize get_optimalBufferCopyOffsetAlignment() { return m_struct.optimalBufferCopyOffsetAlignment; } 3379 void set_optimalBufferCopyOffsetAlignment(VkDeviceSize inValue) { m_struct.optimalBufferCopyOffsetAlignment = inValue; } 3380 VkDeviceSize get_optimalBufferCopyRowPitchAlignment() { return m_struct.optimalBufferCopyRowPitchAlignment; } 3381 void set_optimalBufferCopyRowPitchAlignment(VkDeviceSize inValue) { m_struct.optimalBufferCopyRowPitchAlignment = inValue; } 3382 VkDeviceSize get_nonCoherentAtomSize() { return m_struct.nonCoherentAtomSize; } 3383 void set_nonCoherentAtomSize(VkDeviceSize inValue) { m_struct.nonCoherentAtomSize = inValue; } 3384 3385 3386 private: 3387 VkPhysicalDeviceLimits m_struct; 3388 const VkPhysicalDeviceLimits* m_origStructAddr; 3389 uint32_t m_indent; 3390 const char m_dummy_prefix; 3391 void display_struct_members(); 3392 3393 }; 3394 3395 3396 //class declaration 3397 class vkphysicaldevicememoryproperties_struct_wrapper 3398 { 3399 public: 3400 vkphysicaldevicememoryproperties_struct_wrapper(); 3401 vkphysicaldevicememoryproperties_struct_wrapper(VkPhysicalDeviceMemoryProperties* pInStruct); 3402 vkphysicaldevicememoryproperties_struct_wrapper(const VkPhysicalDeviceMemoryProperties* pInStruct); 3403 3404 virtual ~vkphysicaldevicememoryproperties_struct_wrapper(); 3405 3406 void display_txt(); 3407 void display_single_txt(); 3408 void display_full_txt(); 3409 3410 void set_indent(uint32_t indent) { m_indent = indent; } 3411 uint32_t get_memoryTypeCount() { return m_struct.memoryTypeCount; } 3412 void set_memoryTypeCount(uint32_t inValue) { m_struct.memoryTypeCount = inValue; } 3413 uint32_t get_memoryHeapCount() { return m_struct.memoryHeapCount; } 3414 void set_memoryHeapCount(uint32_t inValue) { m_struct.memoryHeapCount = inValue; } 3415 3416 3417 private: 3418 VkPhysicalDeviceMemoryProperties m_struct; 3419 const VkPhysicalDeviceMemoryProperties* m_origStructAddr; 3420 uint32_t m_indent; 3421 const char m_dummy_prefix; 3422 void display_struct_members(); 3423 3424 }; 3425 3426 3427 //class declaration 3428 class vkphysicaldeviceproperties_struct_wrapper 3429 { 3430 public: 3431 vkphysicaldeviceproperties_struct_wrapper(); 3432 vkphysicaldeviceproperties_struct_wrapper(VkPhysicalDeviceProperties* pInStruct); 3433 vkphysicaldeviceproperties_struct_wrapper(const VkPhysicalDeviceProperties* pInStruct); 3434 3435 virtual ~vkphysicaldeviceproperties_struct_wrapper(); 3436 3437 void display_txt(); 3438 void display_single_txt(); 3439 void display_full_txt(); 3440 3441 void set_indent(uint32_t indent) { m_indent = indent; } 3442 uint32_t get_apiVersion() { return m_struct.apiVersion; } 3443 void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; } 3444 uint32_t get_driverVersion() { return m_struct.driverVersion; } 3445 void set_driverVersion(uint32_t inValue) { m_struct.driverVersion = inValue; } 3446 uint32_t get_vendorID() { return m_struct.vendorID; } 3447 void set_vendorID(uint32_t inValue) { m_struct.vendorID = inValue; } 3448 uint32_t get_deviceID() { return m_struct.deviceID; } 3449 void set_deviceID(uint32_t inValue) { m_struct.deviceID = inValue; } 3450 VkPhysicalDeviceType get_deviceType() { return m_struct.deviceType; } 3451 void set_deviceType(VkPhysicalDeviceType inValue) { m_struct.deviceType = inValue; } 3452 VkPhysicalDeviceLimits get_limits() { return m_struct.limits; } 3453 void set_limits(VkPhysicalDeviceLimits inValue) { m_struct.limits = inValue; } 3454 VkPhysicalDeviceSparseProperties get_sparseProperties() { return m_struct.sparseProperties; } 3455 void set_sparseProperties(VkPhysicalDeviceSparseProperties inValue) { m_struct.sparseProperties = inValue; } 3456 3457 3458 private: 3459 VkPhysicalDeviceProperties m_struct; 3460 const VkPhysicalDeviceProperties* m_origStructAddr; 3461 uint32_t m_indent; 3462 const char m_dummy_prefix; 3463 void display_struct_members(); 3464 3465 }; 3466 3467 3468 //class declaration 3469 class vkphysicaldevicesparseproperties_struct_wrapper 3470 { 3471 public: 3472 vkphysicaldevicesparseproperties_struct_wrapper(); 3473 vkphysicaldevicesparseproperties_struct_wrapper(VkPhysicalDeviceSparseProperties* pInStruct); 3474 vkphysicaldevicesparseproperties_struct_wrapper(const VkPhysicalDeviceSparseProperties* pInStruct); 3475 3476 virtual ~vkphysicaldevicesparseproperties_struct_wrapper(); 3477 3478 void display_txt(); 3479 void display_single_txt(); 3480 void display_full_txt(); 3481 3482 void set_indent(uint32_t indent) { m_indent = indent; } 3483 VkBool32 get_residencyStandard2DBlockShape() { return m_struct.residencyStandard2DBlockShape; } 3484 void set_residencyStandard2DBlockShape(VkBool32 inValue) { m_struct.residencyStandard2DBlockShape = inValue; } 3485 VkBool32 get_residencyStandard2DMultisampleBlockShape() { return m_struct.residencyStandard2DMultisampleBlockShape; } 3486 void set_residencyStandard2DMultisampleBlockShape(VkBool32 inValue) { m_struct.residencyStandard2DMultisampleBlockShape = inValue; } 3487 VkBool32 get_residencyStandard3DBlockShape() { return m_struct.residencyStandard3DBlockShape; } 3488 void set_residencyStandard3DBlockShape(VkBool32 inValue) { m_struct.residencyStandard3DBlockShape = inValue; } 3489 VkBool32 get_residencyAlignedMipSize() { return m_struct.residencyAlignedMipSize; } 3490 void set_residencyAlignedMipSize(VkBool32 inValue) { m_struct.residencyAlignedMipSize = inValue; } 3491 VkBool32 get_residencyNonResidentStrict() { return m_struct.residencyNonResidentStrict; } 3492 void set_residencyNonResidentStrict(VkBool32 inValue) { m_struct.residencyNonResidentStrict = inValue; } 3493 3494 3495 private: 3496 VkPhysicalDeviceSparseProperties m_struct; 3497 const VkPhysicalDeviceSparseProperties* m_origStructAddr; 3498 uint32_t m_indent; 3499 const char m_dummy_prefix; 3500 void display_struct_members(); 3501 3502 }; 3503 3504 3505 //class declaration 3506 class vkpipelinecachecreateinfo_struct_wrapper 3507 { 3508 public: 3509 vkpipelinecachecreateinfo_struct_wrapper(); 3510 vkpipelinecachecreateinfo_struct_wrapper(VkPipelineCacheCreateInfo* pInStruct); 3511 vkpipelinecachecreateinfo_struct_wrapper(const VkPipelineCacheCreateInfo* pInStruct); 3512 3513 virtual ~vkpipelinecachecreateinfo_struct_wrapper(); 3514 3515 void display_txt(); 3516 void display_single_txt(); 3517 void display_full_txt(); 3518 3519 void set_indent(uint32_t indent) { m_indent = indent; } 3520 VkStructureType get_sType() { return m_struct.sType; } 3521 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3522 const void* get_pNext() { return m_struct.pNext; } 3523 VkPipelineCacheCreateFlags get_flags() { return m_struct.flags; } 3524 void set_flags(VkPipelineCacheCreateFlags inValue) { m_struct.flags = inValue; } 3525 size_t get_initialDataSize() { return m_struct.initialDataSize; } 3526 void set_initialDataSize(size_t inValue) { m_struct.initialDataSize = inValue; } 3527 const void* get_pInitialData() { return m_struct.pInitialData; } 3528 3529 3530 private: 3531 VkPipelineCacheCreateInfo m_struct; 3532 const VkPipelineCacheCreateInfo* m_origStructAddr; 3533 uint32_t m_indent; 3534 const char m_dummy_prefix; 3535 void display_struct_members(); 3536 3537 }; 3538 3539 3540 //class declaration 3541 class vkpipelinecolorblendattachmentstate_struct_wrapper 3542 { 3543 public: 3544 vkpipelinecolorblendattachmentstate_struct_wrapper(); 3545 vkpipelinecolorblendattachmentstate_struct_wrapper(VkPipelineColorBlendAttachmentState* pInStruct); 3546 vkpipelinecolorblendattachmentstate_struct_wrapper(const VkPipelineColorBlendAttachmentState* pInStruct); 3547 3548 virtual ~vkpipelinecolorblendattachmentstate_struct_wrapper(); 3549 3550 void display_txt(); 3551 void display_single_txt(); 3552 void display_full_txt(); 3553 3554 void set_indent(uint32_t indent) { m_indent = indent; } 3555 VkBool32 get_blendEnable() { return m_struct.blendEnable; } 3556 void set_blendEnable(VkBool32 inValue) { m_struct.blendEnable = inValue; } 3557 VkBlendFactor get_srcColorBlendFactor() { return m_struct.srcColorBlendFactor; } 3558 void set_srcColorBlendFactor(VkBlendFactor inValue) { m_struct.srcColorBlendFactor = inValue; } 3559 VkBlendFactor get_dstColorBlendFactor() { return m_struct.dstColorBlendFactor; } 3560 void set_dstColorBlendFactor(VkBlendFactor inValue) { m_struct.dstColorBlendFactor = inValue; } 3561 VkBlendOp get_colorBlendOp() { return m_struct.colorBlendOp; } 3562 void set_colorBlendOp(VkBlendOp inValue) { m_struct.colorBlendOp = inValue; } 3563 VkBlendFactor get_srcAlphaBlendFactor() { return m_struct.srcAlphaBlendFactor; } 3564 void set_srcAlphaBlendFactor(VkBlendFactor inValue) { m_struct.srcAlphaBlendFactor = inValue; } 3565 VkBlendFactor get_dstAlphaBlendFactor() { return m_struct.dstAlphaBlendFactor; } 3566 void set_dstAlphaBlendFactor(VkBlendFactor inValue) { m_struct.dstAlphaBlendFactor = inValue; } 3567 VkBlendOp get_alphaBlendOp() { return m_struct.alphaBlendOp; } 3568 void set_alphaBlendOp(VkBlendOp inValue) { m_struct.alphaBlendOp = inValue; } 3569 VkColorComponentFlags get_colorWriteMask() { return m_struct.colorWriteMask; } 3570 void set_colorWriteMask(VkColorComponentFlags inValue) { m_struct.colorWriteMask = inValue; } 3571 3572 3573 private: 3574 VkPipelineColorBlendAttachmentState m_struct; 3575 const VkPipelineColorBlendAttachmentState* m_origStructAddr; 3576 uint32_t m_indent; 3577 const char m_dummy_prefix; 3578 void display_struct_members(); 3579 3580 }; 3581 3582 3583 //class declaration 3584 class vkpipelinecolorblendstatecreateinfo_struct_wrapper 3585 { 3586 public: 3587 vkpipelinecolorblendstatecreateinfo_struct_wrapper(); 3588 vkpipelinecolorblendstatecreateinfo_struct_wrapper(VkPipelineColorBlendStateCreateInfo* pInStruct); 3589 vkpipelinecolorblendstatecreateinfo_struct_wrapper(const VkPipelineColorBlendStateCreateInfo* pInStruct); 3590 3591 virtual ~vkpipelinecolorblendstatecreateinfo_struct_wrapper(); 3592 3593 void display_txt(); 3594 void display_single_txt(); 3595 void display_full_txt(); 3596 3597 void set_indent(uint32_t indent) { m_indent = indent; } 3598 VkStructureType get_sType() { return m_struct.sType; } 3599 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3600 const void* get_pNext() { return m_struct.pNext; } 3601 VkPipelineColorBlendStateCreateFlags get_flags() { return m_struct.flags; } 3602 void set_flags(VkPipelineColorBlendStateCreateFlags inValue) { m_struct.flags = inValue; } 3603 VkBool32 get_logicOpEnable() { return m_struct.logicOpEnable; } 3604 void set_logicOpEnable(VkBool32 inValue) { m_struct.logicOpEnable = inValue; } 3605 VkLogicOp get_logicOp() { return m_struct.logicOp; } 3606 void set_logicOp(VkLogicOp inValue) { m_struct.logicOp = inValue; } 3607 uint32_t get_attachmentCount() { return m_struct.attachmentCount; } 3608 void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; } 3609 3610 3611 private: 3612 VkPipelineColorBlendStateCreateInfo m_struct; 3613 const VkPipelineColorBlendStateCreateInfo* m_origStructAddr; 3614 uint32_t m_indent; 3615 const char m_dummy_prefix; 3616 void display_struct_members(); 3617 3618 }; 3619 3620 3621 //class declaration 3622 class vkpipelinedepthstencilstatecreateinfo_struct_wrapper 3623 { 3624 public: 3625 vkpipelinedepthstencilstatecreateinfo_struct_wrapper(); 3626 vkpipelinedepthstencilstatecreateinfo_struct_wrapper(VkPipelineDepthStencilStateCreateInfo* pInStruct); 3627 vkpipelinedepthstencilstatecreateinfo_struct_wrapper(const VkPipelineDepthStencilStateCreateInfo* pInStruct); 3628 3629 virtual ~vkpipelinedepthstencilstatecreateinfo_struct_wrapper(); 3630 3631 void display_txt(); 3632 void display_single_txt(); 3633 void display_full_txt(); 3634 3635 void set_indent(uint32_t indent) { m_indent = indent; } 3636 VkStructureType get_sType() { return m_struct.sType; } 3637 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3638 const void* get_pNext() { return m_struct.pNext; } 3639 VkPipelineDepthStencilStateCreateFlags get_flags() { return m_struct.flags; } 3640 void set_flags(VkPipelineDepthStencilStateCreateFlags inValue) { m_struct.flags = inValue; } 3641 VkBool32 get_depthTestEnable() { return m_struct.depthTestEnable; } 3642 void set_depthTestEnable(VkBool32 inValue) { m_struct.depthTestEnable = inValue; } 3643 VkBool32 get_depthWriteEnable() { return m_struct.depthWriteEnable; } 3644 void set_depthWriteEnable(VkBool32 inValue) { m_struct.depthWriteEnable = inValue; } 3645 VkCompareOp get_depthCompareOp() { return m_struct.depthCompareOp; } 3646 void set_depthCompareOp(VkCompareOp inValue) { m_struct.depthCompareOp = inValue; } 3647 VkBool32 get_depthBoundsTestEnable() { return m_struct.depthBoundsTestEnable; } 3648 void set_depthBoundsTestEnable(VkBool32 inValue) { m_struct.depthBoundsTestEnable = inValue; } 3649 VkBool32 get_stencilTestEnable() { return m_struct.stencilTestEnable; } 3650 void set_stencilTestEnable(VkBool32 inValue) { m_struct.stencilTestEnable = inValue; } 3651 VkStencilOpState get_front() { return m_struct.front; } 3652 void set_front(VkStencilOpState inValue) { m_struct.front = inValue; } 3653 VkStencilOpState get_back() { return m_struct.back; } 3654 void set_back(VkStencilOpState inValue) { m_struct.back = inValue; } 3655 float get_minDepthBounds() { return m_struct.minDepthBounds; } 3656 void set_minDepthBounds(float inValue) { m_struct.minDepthBounds = inValue; } 3657 float get_maxDepthBounds() { return m_struct.maxDepthBounds; } 3658 void set_maxDepthBounds(float inValue) { m_struct.maxDepthBounds = inValue; } 3659 3660 3661 private: 3662 VkPipelineDepthStencilStateCreateInfo m_struct; 3663 const VkPipelineDepthStencilStateCreateInfo* m_origStructAddr; 3664 uint32_t m_indent; 3665 const char m_dummy_prefix; 3666 void display_struct_members(); 3667 3668 }; 3669 3670 3671 //class declaration 3672 class vkpipelinedynamicstatecreateinfo_struct_wrapper 3673 { 3674 public: 3675 vkpipelinedynamicstatecreateinfo_struct_wrapper(); 3676 vkpipelinedynamicstatecreateinfo_struct_wrapper(VkPipelineDynamicStateCreateInfo* pInStruct); 3677 vkpipelinedynamicstatecreateinfo_struct_wrapper(const VkPipelineDynamicStateCreateInfo* pInStruct); 3678 3679 virtual ~vkpipelinedynamicstatecreateinfo_struct_wrapper(); 3680 3681 void display_txt(); 3682 void display_single_txt(); 3683 void display_full_txt(); 3684 3685 void set_indent(uint32_t indent) { m_indent = indent; } 3686 VkStructureType get_sType() { return m_struct.sType; } 3687 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3688 const void* get_pNext() { return m_struct.pNext; } 3689 VkPipelineDynamicStateCreateFlags get_flags() { return m_struct.flags; } 3690 void set_flags(VkPipelineDynamicStateCreateFlags inValue) { m_struct.flags = inValue; } 3691 uint32_t get_dynamicStateCount() { return m_struct.dynamicStateCount; } 3692 void set_dynamicStateCount(uint32_t inValue) { m_struct.dynamicStateCount = inValue; } 3693 3694 3695 private: 3696 VkPipelineDynamicStateCreateInfo m_struct; 3697 const VkPipelineDynamicStateCreateInfo* m_origStructAddr; 3698 uint32_t m_indent; 3699 const char m_dummy_prefix; 3700 void display_struct_members(); 3701 3702 }; 3703 3704 3705 //class declaration 3706 class vkpipelineinputassemblystatecreateinfo_struct_wrapper 3707 { 3708 public: 3709 vkpipelineinputassemblystatecreateinfo_struct_wrapper(); 3710 vkpipelineinputassemblystatecreateinfo_struct_wrapper(VkPipelineInputAssemblyStateCreateInfo* pInStruct); 3711 vkpipelineinputassemblystatecreateinfo_struct_wrapper(const VkPipelineInputAssemblyStateCreateInfo* pInStruct); 3712 3713 virtual ~vkpipelineinputassemblystatecreateinfo_struct_wrapper(); 3714 3715 void display_txt(); 3716 void display_single_txt(); 3717 void display_full_txt(); 3718 3719 void set_indent(uint32_t indent) { m_indent = indent; } 3720 VkStructureType get_sType() { return m_struct.sType; } 3721 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3722 const void* get_pNext() { return m_struct.pNext; } 3723 VkPipelineInputAssemblyStateCreateFlags get_flags() { return m_struct.flags; } 3724 void set_flags(VkPipelineInputAssemblyStateCreateFlags inValue) { m_struct.flags = inValue; } 3725 VkPrimitiveTopology get_topology() { return m_struct.topology; } 3726 void set_topology(VkPrimitiveTopology inValue) { m_struct.topology = inValue; } 3727 VkBool32 get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; } 3728 void set_primitiveRestartEnable(VkBool32 inValue) { m_struct.primitiveRestartEnable = inValue; } 3729 3730 3731 private: 3732 VkPipelineInputAssemblyStateCreateInfo m_struct; 3733 const VkPipelineInputAssemblyStateCreateInfo* m_origStructAddr; 3734 uint32_t m_indent; 3735 const char m_dummy_prefix; 3736 void display_struct_members(); 3737 3738 }; 3739 3740 3741 //class declaration 3742 class vkpipelinelayoutcreateinfo_struct_wrapper 3743 { 3744 public: 3745 vkpipelinelayoutcreateinfo_struct_wrapper(); 3746 vkpipelinelayoutcreateinfo_struct_wrapper(VkPipelineLayoutCreateInfo* pInStruct); 3747 vkpipelinelayoutcreateinfo_struct_wrapper(const VkPipelineLayoutCreateInfo* pInStruct); 3748 3749 virtual ~vkpipelinelayoutcreateinfo_struct_wrapper(); 3750 3751 void display_txt(); 3752 void display_single_txt(); 3753 void display_full_txt(); 3754 3755 void set_indent(uint32_t indent) { m_indent = indent; } 3756 VkStructureType get_sType() { return m_struct.sType; } 3757 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3758 const void* get_pNext() { return m_struct.pNext; } 3759 VkPipelineLayoutCreateFlags get_flags() { return m_struct.flags; } 3760 void set_flags(VkPipelineLayoutCreateFlags inValue) { m_struct.flags = inValue; } 3761 uint32_t get_setLayoutCount() { return m_struct.setLayoutCount; } 3762 void set_setLayoutCount(uint32_t inValue) { m_struct.setLayoutCount = inValue; } 3763 uint32_t get_pushConstantRangeCount() { return m_struct.pushConstantRangeCount; } 3764 void set_pushConstantRangeCount(uint32_t inValue) { m_struct.pushConstantRangeCount = inValue; } 3765 3766 3767 private: 3768 VkPipelineLayoutCreateInfo m_struct; 3769 const VkPipelineLayoutCreateInfo* m_origStructAddr; 3770 uint32_t m_indent; 3771 const char m_dummy_prefix; 3772 void display_struct_members(); 3773 3774 }; 3775 3776 3777 //class declaration 3778 class vkpipelinemultisamplestatecreateinfo_struct_wrapper 3779 { 3780 public: 3781 vkpipelinemultisamplestatecreateinfo_struct_wrapper(); 3782 vkpipelinemultisamplestatecreateinfo_struct_wrapper(VkPipelineMultisampleStateCreateInfo* pInStruct); 3783 vkpipelinemultisamplestatecreateinfo_struct_wrapper(const VkPipelineMultisampleStateCreateInfo* pInStruct); 3784 3785 virtual ~vkpipelinemultisamplestatecreateinfo_struct_wrapper(); 3786 3787 void display_txt(); 3788 void display_single_txt(); 3789 void display_full_txt(); 3790 3791 void set_indent(uint32_t indent) { m_indent = indent; } 3792 VkStructureType get_sType() { return m_struct.sType; } 3793 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3794 const void* get_pNext() { return m_struct.pNext; } 3795 VkPipelineMultisampleStateCreateFlags get_flags() { return m_struct.flags; } 3796 void set_flags(VkPipelineMultisampleStateCreateFlags inValue) { m_struct.flags = inValue; } 3797 VkSampleCountFlagBits get_rasterizationSamples() { return m_struct.rasterizationSamples; } 3798 void set_rasterizationSamples(VkSampleCountFlagBits inValue) { m_struct.rasterizationSamples = inValue; } 3799 VkBool32 get_sampleShadingEnable() { return m_struct.sampleShadingEnable; } 3800 void set_sampleShadingEnable(VkBool32 inValue) { m_struct.sampleShadingEnable = inValue; } 3801 float get_minSampleShading() { return m_struct.minSampleShading; } 3802 void set_minSampleShading(float inValue) { m_struct.minSampleShading = inValue; } 3803 const VkSampleMask* get_pSampleMask() { return m_struct.pSampleMask; } 3804 VkBool32 get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; } 3805 void set_alphaToCoverageEnable(VkBool32 inValue) { m_struct.alphaToCoverageEnable = inValue; } 3806 VkBool32 get_alphaToOneEnable() { return m_struct.alphaToOneEnable; } 3807 void set_alphaToOneEnable(VkBool32 inValue) { m_struct.alphaToOneEnable = inValue; } 3808 3809 3810 private: 3811 VkPipelineMultisampleStateCreateInfo m_struct; 3812 const VkPipelineMultisampleStateCreateInfo* 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 vkpipelinerasterizationstatecreateinfo_struct_wrapper 3822 { 3823 public: 3824 vkpipelinerasterizationstatecreateinfo_struct_wrapper(); 3825 vkpipelinerasterizationstatecreateinfo_struct_wrapper(VkPipelineRasterizationStateCreateInfo* pInStruct); 3826 vkpipelinerasterizationstatecreateinfo_struct_wrapper(const VkPipelineRasterizationStateCreateInfo* pInStruct); 3827 3828 virtual ~vkpipelinerasterizationstatecreateinfo_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 VkStructureType get_sType() { return m_struct.sType; } 3836 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3837 const void* get_pNext() { return m_struct.pNext; } 3838 VkPipelineRasterizationStateCreateFlags get_flags() { return m_struct.flags; } 3839 void set_flags(VkPipelineRasterizationStateCreateFlags inValue) { m_struct.flags = inValue; } 3840 VkBool32 get_depthClampEnable() { return m_struct.depthClampEnable; } 3841 void set_depthClampEnable(VkBool32 inValue) { m_struct.depthClampEnable = inValue; } 3842 VkBool32 get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; } 3843 void set_rasterizerDiscardEnable(VkBool32 inValue) { m_struct.rasterizerDiscardEnable = inValue; } 3844 VkPolygonMode get_polygonMode() { return m_struct.polygonMode; } 3845 void set_polygonMode(VkPolygonMode inValue) { m_struct.polygonMode = inValue; } 3846 VkCullModeFlags get_cullMode() { return m_struct.cullMode; } 3847 void set_cullMode(VkCullModeFlags inValue) { m_struct.cullMode = inValue; } 3848 VkFrontFace get_frontFace() { return m_struct.frontFace; } 3849 void set_frontFace(VkFrontFace inValue) { m_struct.frontFace = inValue; } 3850 VkBool32 get_depthBiasEnable() { return m_struct.depthBiasEnable; } 3851 void set_depthBiasEnable(VkBool32 inValue) { m_struct.depthBiasEnable = inValue; } 3852 float get_depthBiasConstantFactor() { return m_struct.depthBiasConstantFactor; } 3853 void set_depthBiasConstantFactor(float inValue) { m_struct.depthBiasConstantFactor = inValue; } 3854 float get_depthBiasClamp() { return m_struct.depthBiasClamp; } 3855 void set_depthBiasClamp(float inValue) { m_struct.depthBiasClamp = inValue; } 3856 float get_depthBiasSlopeFactor() { return m_struct.depthBiasSlopeFactor; } 3857 void set_depthBiasSlopeFactor(float inValue) { m_struct.depthBiasSlopeFactor = inValue; } 3858 float get_lineWidth() { return m_struct.lineWidth; } 3859 void set_lineWidth(float inValue) { m_struct.lineWidth = inValue; } 3860 3861 3862 private: 3863 VkPipelineRasterizationStateCreateInfo m_struct; 3864 const VkPipelineRasterizationStateCreateInfo* m_origStructAddr; 3865 uint32_t m_indent; 3866 const char m_dummy_prefix; 3867 void display_struct_members(); 3868 3869 }; 3870 3871 3872 //class declaration 3873 class vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper 3874 { 3875 public: 3876 vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper(); 3877 vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper(VkPipelineRasterizationStateRasterizationOrderAMD* pInStruct); 3878 vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper(const VkPipelineRasterizationStateRasterizationOrderAMD* pInStruct); 3879 3880 virtual ~vkpipelinerasterizationstaterasterizationorderamd_struct_wrapper(); 3881 3882 void display_txt(); 3883 void display_single_txt(); 3884 void display_full_txt(); 3885 3886 void set_indent(uint32_t indent) { m_indent = indent; } 3887 VkStructureType get_sType() { return m_struct.sType; } 3888 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3889 const void* get_pNext() { return m_struct.pNext; } 3890 VkRasterizationOrderAMD get_rasterizationOrder() { return m_struct.rasterizationOrder; } 3891 void set_rasterizationOrder(VkRasterizationOrderAMD inValue) { m_struct.rasterizationOrder = inValue; } 3892 3893 3894 private: 3895 VkPipelineRasterizationStateRasterizationOrderAMD m_struct; 3896 const VkPipelineRasterizationStateRasterizationOrderAMD* m_origStructAddr; 3897 uint32_t m_indent; 3898 const char m_dummy_prefix; 3899 void display_struct_members(); 3900 3901 }; 3902 3903 3904 //class declaration 3905 class vkpipelineshaderstagecreateinfo_struct_wrapper 3906 { 3907 public: 3908 vkpipelineshaderstagecreateinfo_struct_wrapper(); 3909 vkpipelineshaderstagecreateinfo_struct_wrapper(VkPipelineShaderStageCreateInfo* pInStruct); 3910 vkpipelineshaderstagecreateinfo_struct_wrapper(const VkPipelineShaderStageCreateInfo* pInStruct); 3911 3912 virtual ~vkpipelineshaderstagecreateinfo_struct_wrapper(); 3913 3914 void display_txt(); 3915 void display_single_txt(); 3916 void display_full_txt(); 3917 3918 void set_indent(uint32_t indent) { m_indent = indent; } 3919 VkStructureType get_sType() { return m_struct.sType; } 3920 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3921 const void* get_pNext() { return m_struct.pNext; } 3922 VkPipelineShaderStageCreateFlags get_flags() { return m_struct.flags; } 3923 void set_flags(VkPipelineShaderStageCreateFlags inValue) { m_struct.flags = inValue; } 3924 VkShaderStageFlagBits get_stage() { return m_struct.stage; } 3925 void set_stage(VkShaderStageFlagBits inValue) { m_struct.stage = inValue; } 3926 VkShaderModule get_module() { return m_struct.module; } 3927 void set_module(VkShaderModule inValue) { m_struct.module = inValue; } 3928 const char* get_pName() { return m_struct.pName; } 3929 const VkSpecializationInfo* get_pSpecializationInfo() { return m_struct.pSpecializationInfo; } 3930 3931 3932 private: 3933 VkPipelineShaderStageCreateInfo m_struct; 3934 const VkPipelineShaderStageCreateInfo* m_origStructAddr; 3935 uint32_t m_indent; 3936 const char m_dummy_prefix; 3937 void display_struct_members(); 3938 3939 }; 3940 3941 3942 //class declaration 3943 class vkpipelinetessellationstatecreateinfo_struct_wrapper 3944 { 3945 public: 3946 vkpipelinetessellationstatecreateinfo_struct_wrapper(); 3947 vkpipelinetessellationstatecreateinfo_struct_wrapper(VkPipelineTessellationStateCreateInfo* pInStruct); 3948 vkpipelinetessellationstatecreateinfo_struct_wrapper(const VkPipelineTessellationStateCreateInfo* pInStruct); 3949 3950 virtual ~vkpipelinetessellationstatecreateinfo_struct_wrapper(); 3951 3952 void display_txt(); 3953 void display_single_txt(); 3954 void display_full_txt(); 3955 3956 void set_indent(uint32_t indent) { m_indent = indent; } 3957 VkStructureType get_sType() { return m_struct.sType; } 3958 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3959 const void* get_pNext() { return m_struct.pNext; } 3960 VkPipelineTessellationStateCreateFlags get_flags() { return m_struct.flags; } 3961 void set_flags(VkPipelineTessellationStateCreateFlags inValue) { m_struct.flags = inValue; } 3962 uint32_t get_patchControlPoints() { return m_struct.patchControlPoints; } 3963 void set_patchControlPoints(uint32_t inValue) { m_struct.patchControlPoints = inValue; } 3964 3965 3966 private: 3967 VkPipelineTessellationStateCreateInfo m_struct; 3968 const VkPipelineTessellationStateCreateInfo* m_origStructAddr; 3969 uint32_t m_indent; 3970 const char m_dummy_prefix; 3971 void display_struct_members(); 3972 3973 }; 3974 3975 3976 //class declaration 3977 class vkpipelinevertexinputstatecreateinfo_struct_wrapper 3978 { 3979 public: 3980 vkpipelinevertexinputstatecreateinfo_struct_wrapper(); 3981 vkpipelinevertexinputstatecreateinfo_struct_wrapper(VkPipelineVertexInputStateCreateInfo* pInStruct); 3982 vkpipelinevertexinputstatecreateinfo_struct_wrapper(const VkPipelineVertexInputStateCreateInfo* pInStruct); 3983 3984 virtual ~vkpipelinevertexinputstatecreateinfo_struct_wrapper(); 3985 3986 void display_txt(); 3987 void display_single_txt(); 3988 void display_full_txt(); 3989 3990 void set_indent(uint32_t indent) { m_indent = indent; } 3991 VkStructureType get_sType() { return m_struct.sType; } 3992 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 3993 const void* get_pNext() { return m_struct.pNext; } 3994 VkPipelineVertexInputStateCreateFlags get_flags() { return m_struct.flags; } 3995 void set_flags(VkPipelineVertexInputStateCreateFlags inValue) { m_struct.flags = inValue; } 3996 uint32_t get_vertexBindingDescriptionCount() { return m_struct.vertexBindingDescriptionCount; } 3997 void set_vertexBindingDescriptionCount(uint32_t inValue) { m_struct.vertexBindingDescriptionCount = inValue; } 3998 uint32_t get_vertexAttributeDescriptionCount() { return m_struct.vertexAttributeDescriptionCount; } 3999 void set_vertexAttributeDescriptionCount(uint32_t inValue) { m_struct.vertexAttributeDescriptionCount = inValue; } 4000 4001 4002 private: 4003 VkPipelineVertexInputStateCreateInfo m_struct; 4004 const VkPipelineVertexInputStateCreateInfo* m_origStructAddr; 4005 uint32_t m_indent; 4006 const char m_dummy_prefix; 4007 void display_struct_members(); 4008 4009 }; 4010 4011 4012 //class declaration 4013 class vkpipelineviewportstatecreateinfo_struct_wrapper 4014 { 4015 public: 4016 vkpipelineviewportstatecreateinfo_struct_wrapper(); 4017 vkpipelineviewportstatecreateinfo_struct_wrapper(VkPipelineViewportStateCreateInfo* pInStruct); 4018 vkpipelineviewportstatecreateinfo_struct_wrapper(const VkPipelineViewportStateCreateInfo* pInStruct); 4019 4020 virtual ~vkpipelineviewportstatecreateinfo_struct_wrapper(); 4021 4022 void display_txt(); 4023 void display_single_txt(); 4024 void display_full_txt(); 4025 4026 void set_indent(uint32_t indent) { m_indent = indent; } 4027 VkStructureType get_sType() { return m_struct.sType; } 4028 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4029 const void* get_pNext() { return m_struct.pNext; } 4030 VkPipelineViewportStateCreateFlags get_flags() { return m_struct.flags; } 4031 void set_flags(VkPipelineViewportStateCreateFlags inValue) { m_struct.flags = inValue; } 4032 uint32_t get_viewportCount() { return m_struct.viewportCount; } 4033 void set_viewportCount(uint32_t inValue) { m_struct.viewportCount = inValue; } 4034 uint32_t get_scissorCount() { return m_struct.scissorCount; } 4035 void set_scissorCount(uint32_t inValue) { m_struct.scissorCount = inValue; } 4036 4037 4038 private: 4039 VkPipelineViewportStateCreateInfo m_struct; 4040 const VkPipelineViewportStateCreateInfo* m_origStructAddr; 4041 uint32_t m_indent; 4042 const char m_dummy_prefix; 4043 void display_struct_members(); 4044 4045 }; 4046 4047 4048 //class declaration 4049 class vkpresentinfokhr_struct_wrapper 4050 { 4051 public: 4052 vkpresentinfokhr_struct_wrapper(); 4053 vkpresentinfokhr_struct_wrapper(VkPresentInfoKHR* pInStruct); 4054 vkpresentinfokhr_struct_wrapper(const VkPresentInfoKHR* pInStruct); 4055 4056 virtual ~vkpresentinfokhr_struct_wrapper(); 4057 4058 void display_txt(); 4059 void display_single_txt(); 4060 void display_full_txt(); 4061 4062 void set_indent(uint32_t indent) { m_indent = indent; } 4063 VkStructureType get_sType() { return m_struct.sType; } 4064 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4065 const void* get_pNext() { return m_struct.pNext; } 4066 uint32_t get_waitSemaphoreCount() { return m_struct.waitSemaphoreCount; } 4067 void set_waitSemaphoreCount(uint32_t inValue) { m_struct.waitSemaphoreCount = inValue; } 4068 uint32_t get_swapchainCount() { return m_struct.swapchainCount; } 4069 void set_swapchainCount(uint32_t inValue) { m_struct.swapchainCount = inValue; } 4070 VkResult* get_pResults() { return m_struct.pResults; } 4071 void set_pResults(VkResult* inValue) { m_struct.pResults = inValue; } 4072 4073 4074 private: 4075 VkPresentInfoKHR m_struct; 4076 const VkPresentInfoKHR* m_origStructAddr; 4077 uint32_t m_indent; 4078 const char m_dummy_prefix; 4079 void display_struct_members(); 4080 4081 }; 4082 4083 4084 //class declaration 4085 class vkpushconstantrange_struct_wrapper 4086 { 4087 public: 4088 vkpushconstantrange_struct_wrapper(); 4089 vkpushconstantrange_struct_wrapper(VkPushConstantRange* pInStruct); 4090 vkpushconstantrange_struct_wrapper(const VkPushConstantRange* pInStruct); 4091 4092 virtual ~vkpushconstantrange_struct_wrapper(); 4093 4094 void display_txt(); 4095 void display_single_txt(); 4096 void display_full_txt(); 4097 4098 void set_indent(uint32_t indent) { m_indent = indent; } 4099 VkShaderStageFlags get_stageFlags() { return m_struct.stageFlags; } 4100 void set_stageFlags(VkShaderStageFlags inValue) { m_struct.stageFlags = inValue; } 4101 uint32_t get_offset() { return m_struct.offset; } 4102 void set_offset(uint32_t inValue) { m_struct.offset = inValue; } 4103 uint32_t get_size() { return m_struct.size; } 4104 void set_size(uint32_t inValue) { m_struct.size = inValue; } 4105 4106 4107 private: 4108 VkPushConstantRange m_struct; 4109 const VkPushConstantRange* m_origStructAddr; 4110 uint32_t m_indent; 4111 const char m_dummy_prefix; 4112 void display_struct_members(); 4113 4114 }; 4115 4116 4117 //class declaration 4118 class vkquerypoolcreateinfo_struct_wrapper 4119 { 4120 public: 4121 vkquerypoolcreateinfo_struct_wrapper(); 4122 vkquerypoolcreateinfo_struct_wrapper(VkQueryPoolCreateInfo* pInStruct); 4123 vkquerypoolcreateinfo_struct_wrapper(const VkQueryPoolCreateInfo* pInStruct); 4124 4125 virtual ~vkquerypoolcreateinfo_struct_wrapper(); 4126 4127 void display_txt(); 4128 void display_single_txt(); 4129 void display_full_txt(); 4130 4131 void set_indent(uint32_t indent) { m_indent = indent; } 4132 VkStructureType get_sType() { return m_struct.sType; } 4133 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4134 const void* get_pNext() { return m_struct.pNext; } 4135 VkQueryPoolCreateFlags get_flags() { return m_struct.flags; } 4136 void set_flags(VkQueryPoolCreateFlags inValue) { m_struct.flags = inValue; } 4137 VkQueryType get_queryType() { return m_struct.queryType; } 4138 void set_queryType(VkQueryType inValue) { m_struct.queryType = inValue; } 4139 uint32_t get_queryCount() { return m_struct.queryCount; } 4140 void set_queryCount(uint32_t inValue) { m_struct.queryCount = inValue; } 4141 VkQueryPipelineStatisticFlags get_pipelineStatistics() { return m_struct.pipelineStatistics; } 4142 void set_pipelineStatistics(VkQueryPipelineStatisticFlags inValue) { m_struct.pipelineStatistics = inValue; } 4143 4144 4145 private: 4146 VkQueryPoolCreateInfo m_struct; 4147 const VkQueryPoolCreateInfo* m_origStructAddr; 4148 uint32_t m_indent; 4149 const char m_dummy_prefix; 4150 void display_struct_members(); 4151 4152 }; 4153 4154 4155 //class declaration 4156 class vkqueuefamilyproperties_struct_wrapper 4157 { 4158 public: 4159 vkqueuefamilyproperties_struct_wrapper(); 4160 vkqueuefamilyproperties_struct_wrapper(VkQueueFamilyProperties* pInStruct); 4161 vkqueuefamilyproperties_struct_wrapper(const VkQueueFamilyProperties* pInStruct); 4162 4163 virtual ~vkqueuefamilyproperties_struct_wrapper(); 4164 4165 void display_txt(); 4166 void display_single_txt(); 4167 void display_full_txt(); 4168 4169 void set_indent(uint32_t indent) { m_indent = indent; } 4170 VkQueueFlags get_queueFlags() { return m_struct.queueFlags; } 4171 void set_queueFlags(VkQueueFlags inValue) { m_struct.queueFlags = inValue; } 4172 uint32_t get_queueCount() { return m_struct.queueCount; } 4173 void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; } 4174 uint32_t get_timestampValidBits() { return m_struct.timestampValidBits; } 4175 void set_timestampValidBits(uint32_t inValue) { m_struct.timestampValidBits = inValue; } 4176 VkExtent3D get_minImageTransferGranularity() { return m_struct.minImageTransferGranularity; } 4177 void set_minImageTransferGranularity(VkExtent3D inValue) { m_struct.minImageTransferGranularity = inValue; } 4178 4179 4180 private: 4181 VkQueueFamilyProperties m_struct; 4182 const VkQueueFamilyProperties* m_origStructAddr; 4183 uint32_t m_indent; 4184 const char m_dummy_prefix; 4185 void display_struct_members(); 4186 4187 }; 4188 4189 4190 //class declaration 4191 class vkrect2d_struct_wrapper 4192 { 4193 public: 4194 vkrect2d_struct_wrapper(); 4195 vkrect2d_struct_wrapper(VkRect2D* pInStruct); 4196 vkrect2d_struct_wrapper(const VkRect2D* pInStruct); 4197 4198 virtual ~vkrect2d_struct_wrapper(); 4199 4200 void display_txt(); 4201 void display_single_txt(); 4202 void display_full_txt(); 4203 4204 void set_indent(uint32_t indent) { m_indent = indent; } 4205 VkOffset2D get_offset() { return m_struct.offset; } 4206 void set_offset(VkOffset2D inValue) { m_struct.offset = inValue; } 4207 VkExtent2D get_extent() { return m_struct.extent; } 4208 void set_extent(VkExtent2D inValue) { m_struct.extent = inValue; } 4209 4210 4211 private: 4212 VkRect2D m_struct; 4213 const VkRect2D* m_origStructAddr; 4214 uint32_t m_indent; 4215 const char m_dummy_prefix; 4216 void display_struct_members(); 4217 4218 }; 4219 4220 4221 //class declaration 4222 class vkrenderpassbegininfo_struct_wrapper 4223 { 4224 public: 4225 vkrenderpassbegininfo_struct_wrapper(); 4226 vkrenderpassbegininfo_struct_wrapper(VkRenderPassBeginInfo* pInStruct); 4227 vkrenderpassbegininfo_struct_wrapper(const VkRenderPassBeginInfo* pInStruct); 4228 4229 virtual ~vkrenderpassbegininfo_struct_wrapper(); 4230 4231 void display_txt(); 4232 void display_single_txt(); 4233 void display_full_txt(); 4234 4235 void set_indent(uint32_t indent) { m_indent = indent; } 4236 VkStructureType get_sType() { return m_struct.sType; } 4237 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4238 const void* get_pNext() { return m_struct.pNext; } 4239 VkRenderPass get_renderPass() { return m_struct.renderPass; } 4240 void set_renderPass(VkRenderPass inValue) { m_struct.renderPass = inValue; } 4241 VkFramebuffer get_framebuffer() { return m_struct.framebuffer; } 4242 void set_framebuffer(VkFramebuffer inValue) { m_struct.framebuffer = inValue; } 4243 VkRect2D get_renderArea() { return m_struct.renderArea; } 4244 void set_renderArea(VkRect2D inValue) { m_struct.renderArea = inValue; } 4245 uint32_t get_clearValueCount() { return m_struct.clearValueCount; } 4246 void set_clearValueCount(uint32_t inValue) { m_struct.clearValueCount = inValue; } 4247 4248 4249 private: 4250 VkRenderPassBeginInfo m_struct; 4251 const VkRenderPassBeginInfo* m_origStructAddr; 4252 uint32_t m_indent; 4253 const char m_dummy_prefix; 4254 void display_struct_members(); 4255 4256 }; 4257 4258 4259 //class declaration 4260 class vkrenderpasscreateinfo_struct_wrapper 4261 { 4262 public: 4263 vkrenderpasscreateinfo_struct_wrapper(); 4264 vkrenderpasscreateinfo_struct_wrapper(VkRenderPassCreateInfo* pInStruct); 4265 vkrenderpasscreateinfo_struct_wrapper(const VkRenderPassCreateInfo* pInStruct); 4266 4267 virtual ~vkrenderpasscreateinfo_struct_wrapper(); 4268 4269 void display_txt(); 4270 void display_single_txt(); 4271 void display_full_txt(); 4272 4273 void set_indent(uint32_t indent) { m_indent = indent; } 4274 VkStructureType get_sType() { return m_struct.sType; } 4275 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4276 const void* get_pNext() { return m_struct.pNext; } 4277 VkRenderPassCreateFlags get_flags() { return m_struct.flags; } 4278 void set_flags(VkRenderPassCreateFlags inValue) { m_struct.flags = inValue; } 4279 uint32_t get_attachmentCount() { return m_struct.attachmentCount; } 4280 void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; } 4281 uint32_t get_subpassCount() { return m_struct.subpassCount; } 4282 void set_subpassCount(uint32_t inValue) { m_struct.subpassCount = inValue; } 4283 uint32_t get_dependencyCount() { return m_struct.dependencyCount; } 4284 void set_dependencyCount(uint32_t inValue) { m_struct.dependencyCount = inValue; } 4285 4286 4287 private: 4288 VkRenderPassCreateInfo m_struct; 4289 const VkRenderPassCreateInfo* m_origStructAddr; 4290 uint32_t m_indent; 4291 const char m_dummy_prefix; 4292 void display_struct_members(); 4293 4294 }; 4295 4296 4297 //class declaration 4298 class vksamplercreateinfo_struct_wrapper 4299 { 4300 public: 4301 vksamplercreateinfo_struct_wrapper(); 4302 vksamplercreateinfo_struct_wrapper(VkSamplerCreateInfo* pInStruct); 4303 vksamplercreateinfo_struct_wrapper(const VkSamplerCreateInfo* pInStruct); 4304 4305 virtual ~vksamplercreateinfo_struct_wrapper(); 4306 4307 void display_txt(); 4308 void display_single_txt(); 4309 void display_full_txt(); 4310 4311 void set_indent(uint32_t indent) { m_indent = indent; } 4312 VkStructureType get_sType() { return m_struct.sType; } 4313 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4314 const void* get_pNext() { return m_struct.pNext; } 4315 VkSamplerCreateFlags get_flags() { return m_struct.flags; } 4316 void set_flags(VkSamplerCreateFlags inValue) { m_struct.flags = inValue; } 4317 VkFilter get_magFilter() { return m_struct.magFilter; } 4318 void set_magFilter(VkFilter inValue) { m_struct.magFilter = inValue; } 4319 VkFilter get_minFilter() { return m_struct.minFilter; } 4320 void set_minFilter(VkFilter inValue) { m_struct.minFilter = inValue; } 4321 VkSamplerMipmapMode get_mipmapMode() { return m_struct.mipmapMode; } 4322 void set_mipmapMode(VkSamplerMipmapMode inValue) { m_struct.mipmapMode = inValue; } 4323 VkSamplerAddressMode get_addressModeU() { return m_struct.addressModeU; } 4324 void set_addressModeU(VkSamplerAddressMode inValue) { m_struct.addressModeU = inValue; } 4325 VkSamplerAddressMode get_addressModeV() { return m_struct.addressModeV; } 4326 void set_addressModeV(VkSamplerAddressMode inValue) { m_struct.addressModeV = inValue; } 4327 VkSamplerAddressMode get_addressModeW() { return m_struct.addressModeW; } 4328 void set_addressModeW(VkSamplerAddressMode inValue) { m_struct.addressModeW = inValue; } 4329 float get_mipLodBias() { return m_struct.mipLodBias; } 4330 void set_mipLodBias(float inValue) { m_struct.mipLodBias = inValue; } 4331 VkBool32 get_anisotropyEnable() { return m_struct.anisotropyEnable; } 4332 void set_anisotropyEnable(VkBool32 inValue) { m_struct.anisotropyEnable = inValue; } 4333 float get_maxAnisotropy() { return m_struct.maxAnisotropy; } 4334 void set_maxAnisotropy(float inValue) { m_struct.maxAnisotropy = inValue; } 4335 VkBool32 get_compareEnable() { return m_struct.compareEnable; } 4336 void set_compareEnable(VkBool32 inValue) { m_struct.compareEnable = inValue; } 4337 VkCompareOp get_compareOp() { return m_struct.compareOp; } 4338 void set_compareOp(VkCompareOp inValue) { m_struct.compareOp = inValue; } 4339 float get_minLod() { return m_struct.minLod; } 4340 void set_minLod(float inValue) { m_struct.minLod = inValue; } 4341 float get_maxLod() { return m_struct.maxLod; } 4342 void set_maxLod(float inValue) { m_struct.maxLod = inValue; } 4343 VkBorderColor get_borderColor() { return m_struct.borderColor; } 4344 void set_borderColor(VkBorderColor inValue) { m_struct.borderColor = inValue; } 4345 VkBool32 get_unnormalizedCoordinates() { return m_struct.unnormalizedCoordinates; } 4346 void set_unnormalizedCoordinates(VkBool32 inValue) { m_struct.unnormalizedCoordinates = inValue; } 4347 4348 4349 private: 4350 VkSamplerCreateInfo m_struct; 4351 const VkSamplerCreateInfo* m_origStructAddr; 4352 uint32_t m_indent; 4353 const char m_dummy_prefix; 4354 void display_struct_members(); 4355 4356 }; 4357 4358 4359 //class declaration 4360 class vksemaphorecreateinfo_struct_wrapper 4361 { 4362 public: 4363 vksemaphorecreateinfo_struct_wrapper(); 4364 vksemaphorecreateinfo_struct_wrapper(VkSemaphoreCreateInfo* pInStruct); 4365 vksemaphorecreateinfo_struct_wrapper(const VkSemaphoreCreateInfo* pInStruct); 4366 4367 virtual ~vksemaphorecreateinfo_struct_wrapper(); 4368 4369 void display_txt(); 4370 void display_single_txt(); 4371 void display_full_txt(); 4372 4373 void set_indent(uint32_t indent) { m_indent = indent; } 4374 VkStructureType get_sType() { return m_struct.sType; } 4375 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4376 const void* get_pNext() { return m_struct.pNext; } 4377 VkSemaphoreCreateFlags get_flags() { return m_struct.flags; } 4378 void set_flags(VkSemaphoreCreateFlags inValue) { m_struct.flags = inValue; } 4379 4380 4381 private: 4382 VkSemaphoreCreateInfo m_struct; 4383 const VkSemaphoreCreateInfo* m_origStructAddr; 4384 uint32_t m_indent; 4385 const char m_dummy_prefix; 4386 void display_struct_members(); 4387 4388 }; 4389 4390 4391 //class declaration 4392 class vkshadermodulecreateinfo_struct_wrapper 4393 { 4394 public: 4395 vkshadermodulecreateinfo_struct_wrapper(); 4396 vkshadermodulecreateinfo_struct_wrapper(VkShaderModuleCreateInfo* pInStruct); 4397 vkshadermodulecreateinfo_struct_wrapper(const VkShaderModuleCreateInfo* pInStruct); 4398 4399 virtual ~vkshadermodulecreateinfo_struct_wrapper(); 4400 4401 void display_txt(); 4402 void display_single_txt(); 4403 void display_full_txt(); 4404 4405 void set_indent(uint32_t indent) { m_indent = indent; } 4406 VkStructureType get_sType() { return m_struct.sType; } 4407 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4408 const void* get_pNext() { return m_struct.pNext; } 4409 VkShaderModuleCreateFlags get_flags() { return m_struct.flags; } 4410 void set_flags(VkShaderModuleCreateFlags inValue) { m_struct.flags = inValue; } 4411 size_t get_codeSize() { return m_struct.codeSize; } 4412 void set_codeSize(size_t inValue) { m_struct.codeSize = inValue; } 4413 const uint32_t* get_pCode() { return m_struct.pCode; } 4414 4415 4416 private: 4417 VkShaderModuleCreateInfo m_struct; 4418 const VkShaderModuleCreateInfo* m_origStructAddr; 4419 uint32_t m_indent; 4420 const char m_dummy_prefix; 4421 void display_struct_members(); 4422 4423 }; 4424 4425 4426 //class declaration 4427 class vksparsebuffermemorybindinfo_struct_wrapper 4428 { 4429 public: 4430 vksparsebuffermemorybindinfo_struct_wrapper(); 4431 vksparsebuffermemorybindinfo_struct_wrapper(VkSparseBufferMemoryBindInfo* pInStruct); 4432 vksparsebuffermemorybindinfo_struct_wrapper(const VkSparseBufferMemoryBindInfo* pInStruct); 4433 4434 virtual ~vksparsebuffermemorybindinfo_struct_wrapper(); 4435 4436 void display_txt(); 4437 void display_single_txt(); 4438 void display_full_txt(); 4439 4440 void set_indent(uint32_t indent) { m_indent = indent; } 4441 VkBuffer get_buffer() { return m_struct.buffer; } 4442 void set_buffer(VkBuffer inValue) { m_struct.buffer = inValue; } 4443 uint32_t get_bindCount() { return m_struct.bindCount; } 4444 void set_bindCount(uint32_t inValue) { m_struct.bindCount = inValue; } 4445 4446 4447 private: 4448 VkSparseBufferMemoryBindInfo m_struct; 4449 const VkSparseBufferMemoryBindInfo* m_origStructAddr; 4450 uint32_t m_indent; 4451 const char m_dummy_prefix; 4452 void display_struct_members(); 4453 4454 }; 4455 4456 4457 //class declaration 4458 class vksparseimageformatproperties_struct_wrapper 4459 { 4460 public: 4461 vksparseimageformatproperties_struct_wrapper(); 4462 vksparseimageformatproperties_struct_wrapper(VkSparseImageFormatProperties* pInStruct); 4463 vksparseimageformatproperties_struct_wrapper(const VkSparseImageFormatProperties* pInStruct); 4464 4465 virtual ~vksparseimageformatproperties_struct_wrapper(); 4466 4467 void display_txt(); 4468 void display_single_txt(); 4469 void display_full_txt(); 4470 4471 void set_indent(uint32_t indent) { m_indent = indent; } 4472 VkImageAspectFlags get_aspectMask() { return m_struct.aspectMask; } 4473 void set_aspectMask(VkImageAspectFlags inValue) { m_struct.aspectMask = inValue; } 4474 VkExtent3D get_imageGranularity() { return m_struct.imageGranularity; } 4475 void set_imageGranularity(VkExtent3D inValue) { m_struct.imageGranularity = inValue; } 4476 VkSparseImageFormatFlags get_flags() { return m_struct.flags; } 4477 void set_flags(VkSparseImageFormatFlags inValue) { m_struct.flags = inValue; } 4478 4479 4480 private: 4481 VkSparseImageFormatProperties m_struct; 4482 const VkSparseImageFormatProperties* m_origStructAddr; 4483 uint32_t m_indent; 4484 const char m_dummy_prefix; 4485 void display_struct_members(); 4486 4487 }; 4488 4489 4490 //class declaration 4491 class vksparseimagememorybind_struct_wrapper 4492 { 4493 public: 4494 vksparseimagememorybind_struct_wrapper(); 4495 vksparseimagememorybind_struct_wrapper(VkSparseImageMemoryBind* pInStruct); 4496 vksparseimagememorybind_struct_wrapper(const VkSparseImageMemoryBind* pInStruct); 4497 4498 virtual ~vksparseimagememorybind_struct_wrapper(); 4499 4500 void display_txt(); 4501 void display_single_txt(); 4502 void display_full_txt(); 4503 4504 void set_indent(uint32_t indent) { m_indent = indent; } 4505 VkImageSubresource get_subresource() { return m_struct.subresource; } 4506 void set_subresource(VkImageSubresource inValue) { m_struct.subresource = inValue; } 4507 VkOffset3D get_offset() { return m_struct.offset; } 4508 void set_offset(VkOffset3D inValue) { m_struct.offset = inValue; } 4509 VkExtent3D get_extent() { return m_struct.extent; } 4510 void set_extent(VkExtent3D inValue) { m_struct.extent = inValue; } 4511 VkDeviceMemory get_memory() { return m_struct.memory; } 4512 void set_memory(VkDeviceMemory inValue) { m_struct.memory = inValue; } 4513 VkDeviceSize get_memoryOffset() { return m_struct.memoryOffset; } 4514 void set_memoryOffset(VkDeviceSize inValue) { m_struct.memoryOffset = inValue; } 4515 VkSparseMemoryBindFlags get_flags() { return m_struct.flags; } 4516 void set_flags(VkSparseMemoryBindFlags inValue) { m_struct.flags = inValue; } 4517 4518 4519 private: 4520 VkSparseImageMemoryBind m_struct; 4521 const VkSparseImageMemoryBind* m_origStructAddr; 4522 uint32_t m_indent; 4523 const char m_dummy_prefix; 4524 void display_struct_members(); 4525 4526 }; 4527 4528 4529 //class declaration 4530 class vksparseimagememorybindinfo_struct_wrapper 4531 { 4532 public: 4533 vksparseimagememorybindinfo_struct_wrapper(); 4534 vksparseimagememorybindinfo_struct_wrapper(VkSparseImageMemoryBindInfo* pInStruct); 4535 vksparseimagememorybindinfo_struct_wrapper(const VkSparseImageMemoryBindInfo* pInStruct); 4536 4537 virtual ~vksparseimagememorybindinfo_struct_wrapper(); 4538 4539 void display_txt(); 4540 void display_single_txt(); 4541 void display_full_txt(); 4542 4543 void set_indent(uint32_t indent) { m_indent = indent; } 4544 VkImage get_image() { return m_struct.image; } 4545 void set_image(VkImage inValue) { m_struct.image = inValue; } 4546 uint32_t get_bindCount() { return m_struct.bindCount; } 4547 void set_bindCount(uint32_t inValue) { m_struct.bindCount = inValue; } 4548 4549 4550 private: 4551 VkSparseImageMemoryBindInfo m_struct; 4552 const VkSparseImageMemoryBindInfo* m_origStructAddr; 4553 uint32_t m_indent; 4554 const char m_dummy_prefix; 4555 void display_struct_members(); 4556 4557 }; 4558 4559 4560 //class declaration 4561 class vksparseimagememoryrequirements_struct_wrapper 4562 { 4563 public: 4564 vksparseimagememoryrequirements_struct_wrapper(); 4565 vksparseimagememoryrequirements_struct_wrapper(VkSparseImageMemoryRequirements* pInStruct); 4566 vksparseimagememoryrequirements_struct_wrapper(const VkSparseImageMemoryRequirements* pInStruct); 4567 4568 virtual ~vksparseimagememoryrequirements_struct_wrapper(); 4569 4570 void display_txt(); 4571 void display_single_txt(); 4572 void display_full_txt(); 4573 4574 void set_indent(uint32_t indent) { m_indent = indent; } 4575 VkSparseImageFormatProperties get_formatProperties() { return m_struct.formatProperties; } 4576 void set_formatProperties(VkSparseImageFormatProperties inValue) { m_struct.formatProperties = inValue; } 4577 uint32_t get_imageMipTailFirstLod() { return m_struct.imageMipTailFirstLod; } 4578 void set_imageMipTailFirstLod(uint32_t inValue) { m_struct.imageMipTailFirstLod = inValue; } 4579 VkDeviceSize get_imageMipTailSize() { return m_struct.imageMipTailSize; } 4580 void set_imageMipTailSize(VkDeviceSize inValue) { m_struct.imageMipTailSize = inValue; } 4581 VkDeviceSize get_imageMipTailOffset() { return m_struct.imageMipTailOffset; } 4582 void set_imageMipTailOffset(VkDeviceSize inValue) { m_struct.imageMipTailOffset = inValue; } 4583 VkDeviceSize get_imageMipTailStride() { return m_struct.imageMipTailStride; } 4584 void set_imageMipTailStride(VkDeviceSize inValue) { m_struct.imageMipTailStride = inValue; } 4585 4586 4587 private: 4588 VkSparseImageMemoryRequirements m_struct; 4589 const VkSparseImageMemoryRequirements* m_origStructAddr; 4590 uint32_t m_indent; 4591 const char m_dummy_prefix; 4592 void display_struct_members(); 4593 4594 }; 4595 4596 4597 //class declaration 4598 class vksparseimageopaquememorybindinfo_struct_wrapper 4599 { 4600 public: 4601 vksparseimageopaquememorybindinfo_struct_wrapper(); 4602 vksparseimageopaquememorybindinfo_struct_wrapper(VkSparseImageOpaqueMemoryBindInfo* pInStruct); 4603 vksparseimageopaquememorybindinfo_struct_wrapper(const VkSparseImageOpaqueMemoryBindInfo* pInStruct); 4604 4605 virtual ~vksparseimageopaquememorybindinfo_struct_wrapper(); 4606 4607 void display_txt(); 4608 void display_single_txt(); 4609 void display_full_txt(); 4610 4611 void set_indent(uint32_t indent) { m_indent = indent; } 4612 VkImage get_image() { return m_struct.image; } 4613 void set_image(VkImage inValue) { m_struct.image = inValue; } 4614 uint32_t get_bindCount() { return m_struct.bindCount; } 4615 void set_bindCount(uint32_t inValue) { m_struct.bindCount = inValue; } 4616 4617 4618 private: 4619 VkSparseImageOpaqueMemoryBindInfo m_struct; 4620 const VkSparseImageOpaqueMemoryBindInfo* m_origStructAddr; 4621 uint32_t m_indent; 4622 const char m_dummy_prefix; 4623 void display_struct_members(); 4624 4625 }; 4626 4627 4628 //class declaration 4629 class vksparsememorybind_struct_wrapper 4630 { 4631 public: 4632 vksparsememorybind_struct_wrapper(); 4633 vksparsememorybind_struct_wrapper(VkSparseMemoryBind* pInStruct); 4634 vksparsememorybind_struct_wrapper(const VkSparseMemoryBind* pInStruct); 4635 4636 virtual ~vksparsememorybind_struct_wrapper(); 4637 4638 void display_txt(); 4639 void display_single_txt(); 4640 void display_full_txt(); 4641 4642 void set_indent(uint32_t indent) { m_indent = indent; } 4643 VkDeviceSize get_resourceOffset() { return m_struct.resourceOffset; } 4644 void set_resourceOffset(VkDeviceSize inValue) { m_struct.resourceOffset = inValue; } 4645 VkDeviceSize get_size() { return m_struct.size; } 4646 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 4647 VkDeviceMemory get_memory() { return m_struct.memory; } 4648 void set_memory(VkDeviceMemory inValue) { m_struct.memory = inValue; } 4649 VkDeviceSize get_memoryOffset() { return m_struct.memoryOffset; } 4650 void set_memoryOffset(VkDeviceSize inValue) { m_struct.memoryOffset = inValue; } 4651 VkSparseMemoryBindFlags get_flags() { return m_struct.flags; } 4652 void set_flags(VkSparseMemoryBindFlags inValue) { m_struct.flags = inValue; } 4653 4654 4655 private: 4656 VkSparseMemoryBind m_struct; 4657 const VkSparseMemoryBind* m_origStructAddr; 4658 uint32_t m_indent; 4659 const char m_dummy_prefix; 4660 void display_struct_members(); 4661 4662 }; 4663 4664 4665 //class declaration 4666 class vkspecializationinfo_struct_wrapper 4667 { 4668 public: 4669 vkspecializationinfo_struct_wrapper(); 4670 vkspecializationinfo_struct_wrapper(VkSpecializationInfo* pInStruct); 4671 vkspecializationinfo_struct_wrapper(const VkSpecializationInfo* pInStruct); 4672 4673 virtual ~vkspecializationinfo_struct_wrapper(); 4674 4675 void display_txt(); 4676 void display_single_txt(); 4677 void display_full_txt(); 4678 4679 void set_indent(uint32_t indent) { m_indent = indent; } 4680 uint32_t get_mapEntryCount() { return m_struct.mapEntryCount; } 4681 void set_mapEntryCount(uint32_t inValue) { m_struct.mapEntryCount = inValue; } 4682 size_t get_dataSize() { return m_struct.dataSize; } 4683 void set_dataSize(size_t inValue) { m_struct.dataSize = inValue; } 4684 const void* get_pData() { return m_struct.pData; } 4685 4686 4687 private: 4688 VkSpecializationInfo m_struct; 4689 const VkSpecializationInfo* m_origStructAddr; 4690 uint32_t m_indent; 4691 const char m_dummy_prefix; 4692 void display_struct_members(); 4693 4694 }; 4695 4696 4697 //class declaration 4698 class vkspecializationmapentry_struct_wrapper 4699 { 4700 public: 4701 vkspecializationmapentry_struct_wrapper(); 4702 vkspecializationmapentry_struct_wrapper(VkSpecializationMapEntry* pInStruct); 4703 vkspecializationmapentry_struct_wrapper(const VkSpecializationMapEntry* pInStruct); 4704 4705 virtual ~vkspecializationmapentry_struct_wrapper(); 4706 4707 void display_txt(); 4708 void display_single_txt(); 4709 void display_full_txt(); 4710 4711 void set_indent(uint32_t indent) { m_indent = indent; } 4712 uint32_t get_constantID() { return m_struct.constantID; } 4713 void set_constantID(uint32_t inValue) { m_struct.constantID = inValue; } 4714 uint32_t get_offset() { return m_struct.offset; } 4715 void set_offset(uint32_t inValue) { m_struct.offset = inValue; } 4716 size_t get_size() { return m_struct.size; } 4717 void set_size(size_t inValue) { m_struct.size = inValue; } 4718 4719 4720 private: 4721 VkSpecializationMapEntry m_struct; 4722 const VkSpecializationMapEntry* m_origStructAddr; 4723 uint32_t m_indent; 4724 const char m_dummy_prefix; 4725 void display_struct_members(); 4726 4727 }; 4728 4729 4730 //class declaration 4731 class vkstencilopstate_struct_wrapper 4732 { 4733 public: 4734 vkstencilopstate_struct_wrapper(); 4735 vkstencilopstate_struct_wrapper(VkStencilOpState* pInStruct); 4736 vkstencilopstate_struct_wrapper(const VkStencilOpState* pInStruct); 4737 4738 virtual ~vkstencilopstate_struct_wrapper(); 4739 4740 void display_txt(); 4741 void display_single_txt(); 4742 void display_full_txt(); 4743 4744 void set_indent(uint32_t indent) { m_indent = indent; } 4745 VkStencilOp get_failOp() { return m_struct.failOp; } 4746 void set_failOp(VkStencilOp inValue) { m_struct.failOp = inValue; } 4747 VkStencilOp get_passOp() { return m_struct.passOp; } 4748 void set_passOp(VkStencilOp inValue) { m_struct.passOp = inValue; } 4749 VkStencilOp get_depthFailOp() { return m_struct.depthFailOp; } 4750 void set_depthFailOp(VkStencilOp inValue) { m_struct.depthFailOp = inValue; } 4751 VkCompareOp get_compareOp() { return m_struct.compareOp; } 4752 void set_compareOp(VkCompareOp inValue) { m_struct.compareOp = inValue; } 4753 uint32_t get_compareMask() { return m_struct.compareMask; } 4754 void set_compareMask(uint32_t inValue) { m_struct.compareMask = inValue; } 4755 uint32_t get_writeMask() { return m_struct.writeMask; } 4756 void set_writeMask(uint32_t inValue) { m_struct.writeMask = inValue; } 4757 uint32_t get_reference() { return m_struct.reference; } 4758 void set_reference(uint32_t inValue) { m_struct.reference = inValue; } 4759 4760 4761 private: 4762 VkStencilOpState m_struct; 4763 const VkStencilOpState* m_origStructAddr; 4764 uint32_t m_indent; 4765 const char m_dummy_prefix; 4766 void display_struct_members(); 4767 4768 }; 4769 4770 4771 //class declaration 4772 class vksubmitinfo_struct_wrapper 4773 { 4774 public: 4775 vksubmitinfo_struct_wrapper(); 4776 vksubmitinfo_struct_wrapper(VkSubmitInfo* pInStruct); 4777 vksubmitinfo_struct_wrapper(const VkSubmitInfo* pInStruct); 4778 4779 virtual ~vksubmitinfo_struct_wrapper(); 4780 4781 void display_txt(); 4782 void display_single_txt(); 4783 void display_full_txt(); 4784 4785 void set_indent(uint32_t indent) { m_indent = indent; } 4786 VkStructureType get_sType() { return m_struct.sType; } 4787 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 4788 const void* get_pNext() { return m_struct.pNext; } 4789 uint32_t get_waitSemaphoreCount() { return m_struct.waitSemaphoreCount; } 4790 void set_waitSemaphoreCount(uint32_t inValue) { m_struct.waitSemaphoreCount = inValue; } 4791 const VkPipelineStageFlags* get_pWaitDstStageMask() { return m_struct.pWaitDstStageMask; } 4792 uint32_t get_commandBufferCount() { return m_struct.commandBufferCount; } 4793 void set_commandBufferCount(uint32_t inValue) { m_struct.commandBufferCount = inValue; } 4794 uint32_t get_signalSemaphoreCount() { return m_struct.signalSemaphoreCount; } 4795 void set_signalSemaphoreCount(uint32_t inValue) { m_struct.signalSemaphoreCount = inValue; } 4796 4797 4798 private: 4799 VkSubmitInfo m_struct; 4800 const VkSubmitInfo* m_origStructAddr; 4801 uint32_t m_indent; 4802 const char m_dummy_prefix; 4803 void display_struct_members(); 4804 4805 }; 4806 4807 4808 //class declaration 4809 class vksubpassdependency_struct_wrapper 4810 { 4811 public: 4812 vksubpassdependency_struct_wrapper(); 4813 vksubpassdependency_struct_wrapper(VkSubpassDependency* pInStruct); 4814 vksubpassdependency_struct_wrapper(const VkSubpassDependency* pInStruct); 4815 4816 virtual ~vksubpassdependency_struct_wrapper(); 4817 4818 void display_txt(); 4819 void display_single_txt(); 4820 void display_full_txt(); 4821 4822 void set_indent(uint32_t indent) { m_indent = indent; } 4823 uint32_t get_srcSubpass() { return m_struct.srcSubpass; } 4824 void set_srcSubpass(uint32_t inValue) { m_struct.srcSubpass = inValue; } 4825 uint32_t get_dstSubpass() { return m_struct.dstSubpass; } 4826 void set_dstSubpass(uint32_t inValue) { m_struct.dstSubpass = inValue; } 4827 VkPipelineStageFlags get_srcStageMask() { return m_struct.srcStageMask; } 4828 void set_srcStageMask(VkPipelineStageFlags inValue) { m_struct.srcStageMask = inValue; } 4829 VkPipelineStageFlags get_dstStageMask() { return m_struct.dstStageMask; } 4830 void set_dstStageMask(VkPipelineStageFlags inValue) { m_struct.dstStageMask = inValue; } 4831 VkAccessFlags get_srcAccessMask() { return m_struct.srcAccessMask; } 4832 void set_srcAccessMask(VkAccessFlags inValue) { m_struct.srcAccessMask = inValue; } 4833 VkAccessFlags get_dstAccessMask() { return m_struct.dstAccessMask; } 4834 void set_dstAccessMask(VkAccessFlags inValue) { m_struct.dstAccessMask = inValue; } 4835 VkDependencyFlags get_dependencyFlags() { return m_struct.dependencyFlags; } 4836 void set_dependencyFlags(VkDependencyFlags inValue) { m_struct.dependencyFlags = inValue; } 4837 4838 4839 private: 4840 VkSubpassDependency m_struct; 4841 const VkSubpassDependency* m_origStructAddr; 4842 uint32_t m_indent; 4843 const char m_dummy_prefix; 4844 void display_struct_members(); 4845 4846 }; 4847 4848 4849 //class declaration 4850 class vksubpassdescription_struct_wrapper 4851 { 4852 public: 4853 vksubpassdescription_struct_wrapper(); 4854 vksubpassdescription_struct_wrapper(VkSubpassDescription* pInStruct); 4855 vksubpassdescription_struct_wrapper(const VkSubpassDescription* pInStruct); 4856 4857 virtual ~vksubpassdescription_struct_wrapper(); 4858 4859 void display_txt(); 4860 void display_single_txt(); 4861 void display_full_txt(); 4862 4863 void set_indent(uint32_t indent) { m_indent = indent; } 4864 VkSubpassDescriptionFlags get_flags() { return m_struct.flags; } 4865 void set_flags(VkSubpassDescriptionFlags inValue) { m_struct.flags = inValue; } 4866 VkPipelineBindPoint get_pipelineBindPoint() { return m_struct.pipelineBindPoint; } 4867 void set_pipelineBindPoint(VkPipelineBindPoint inValue) { m_struct.pipelineBindPoint = inValue; } 4868 uint32_t get_inputAttachmentCount() { return m_struct.inputAttachmentCount; } 4869 void set_inputAttachmentCount(uint32_t inValue) { m_struct.inputAttachmentCount = inValue; } 4870 uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; } 4871 void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; } 4872 const VkAttachmentReference* get_pDepthStencilAttachment() { return m_struct.pDepthStencilAttachment; } 4873 uint32_t get_preserveAttachmentCount() { return m_struct.preserveAttachmentCount; } 4874 void set_preserveAttachmentCount(uint32_t inValue) { m_struct.preserveAttachmentCount = inValue; } 4875 4876 4877 private: 4878 VkSubpassDescription m_struct; 4879 const VkSubpassDescription* m_origStructAddr; 4880 uint32_t m_indent; 4881 const char m_dummy_prefix; 4882 void display_struct_members(); 4883 4884 }; 4885 4886 4887 //class declaration 4888 class vksubresourcelayout_struct_wrapper 4889 { 4890 public: 4891 vksubresourcelayout_struct_wrapper(); 4892 vksubresourcelayout_struct_wrapper(VkSubresourceLayout* pInStruct); 4893 vksubresourcelayout_struct_wrapper(const VkSubresourceLayout* pInStruct); 4894 4895 virtual ~vksubresourcelayout_struct_wrapper(); 4896 4897 void display_txt(); 4898 void display_single_txt(); 4899 void display_full_txt(); 4900 4901 void set_indent(uint32_t indent) { m_indent = indent; } 4902 VkDeviceSize get_offset() { return m_struct.offset; } 4903 void set_offset(VkDeviceSize inValue) { m_struct.offset = inValue; } 4904 VkDeviceSize get_size() { return m_struct.size; } 4905 void set_size(VkDeviceSize inValue) { m_struct.size = inValue; } 4906 VkDeviceSize get_rowPitch() { return m_struct.rowPitch; } 4907 void set_rowPitch(VkDeviceSize inValue) { m_struct.rowPitch = inValue; } 4908 VkDeviceSize get_arrayPitch() { return m_struct.arrayPitch; } 4909 void set_arrayPitch(VkDeviceSize inValue) { m_struct.arrayPitch = inValue; } 4910 VkDeviceSize get_depthPitch() { return m_struct.depthPitch; } 4911 void set_depthPitch(VkDeviceSize inValue) { m_struct.depthPitch = inValue; } 4912 4913 4914 private: 4915 VkSubresourceLayout m_struct; 4916 const VkSubresourceLayout* m_origStructAddr; 4917 uint32_t m_indent; 4918 const char m_dummy_prefix; 4919 void display_struct_members(); 4920 4921 }; 4922 4923 4924 //class declaration 4925 class vksurfacecapabilitieskhr_struct_wrapper 4926 { 4927 public: 4928 vksurfacecapabilitieskhr_struct_wrapper(); 4929 vksurfacecapabilitieskhr_struct_wrapper(VkSurfaceCapabilitiesKHR* pInStruct); 4930 vksurfacecapabilitieskhr_struct_wrapper(const VkSurfaceCapabilitiesKHR* pInStruct); 4931 4932 virtual ~vksurfacecapabilitieskhr_struct_wrapper(); 4933 4934 void display_txt(); 4935 void display_single_txt(); 4936 void display_full_txt(); 4937 4938 void set_indent(uint32_t indent) { m_indent = indent; } 4939 uint32_t get_minImageCount() { return m_struct.minImageCount; } 4940 void set_minImageCount(uint32_t inValue) { m_struct.minImageCount = inValue; } 4941 uint32_t get_maxImageCount() { return m_struct.maxImageCount; } 4942 void set_maxImageCount(uint32_t inValue) { m_struct.maxImageCount = inValue; } 4943 VkExtent2D get_currentExtent() { return m_struct.currentExtent; } 4944 void set_currentExtent(VkExtent2D inValue) { m_struct.currentExtent = inValue; } 4945 VkExtent2D get_minImageExtent() { return m_struct.minImageExtent; } 4946 void set_minImageExtent(VkExtent2D inValue) { m_struct.minImageExtent = inValue; } 4947 VkExtent2D get_maxImageExtent() { return m_struct.maxImageExtent; } 4948 void set_maxImageExtent(VkExtent2D inValue) { m_struct.maxImageExtent = inValue; } 4949 uint32_t get_maxImageArrayLayers() { return m_struct.maxImageArrayLayers; } 4950 void set_maxImageArrayLayers(uint32_t inValue) { m_struct.maxImageArrayLayers = inValue; } 4951 VkSurfaceTransformFlagsKHR get_supportedTransforms() { return m_struct.supportedTransforms; } 4952 void set_supportedTransforms(VkSurfaceTransformFlagsKHR inValue) { m_struct.supportedTransforms = inValue; } 4953 VkSurfaceTransformFlagBitsKHR get_currentTransform() { return m_struct.currentTransform; } 4954 void set_currentTransform(VkSurfaceTransformFlagBitsKHR inValue) { m_struct.currentTransform = inValue; } 4955 VkCompositeAlphaFlagsKHR get_supportedCompositeAlpha() { return m_struct.supportedCompositeAlpha; } 4956 void set_supportedCompositeAlpha(VkCompositeAlphaFlagsKHR inValue) { m_struct.supportedCompositeAlpha = inValue; } 4957 VkImageUsageFlags get_supportedUsageFlags() { return m_struct.supportedUsageFlags; } 4958 void set_supportedUsageFlags(VkImageUsageFlags inValue) { m_struct.supportedUsageFlags = inValue; } 4959 4960 4961 private: 4962 VkSurfaceCapabilitiesKHR m_struct; 4963 const VkSurfaceCapabilitiesKHR* m_origStructAddr; 4964 uint32_t m_indent; 4965 const char m_dummy_prefix; 4966 void display_struct_members(); 4967 4968 }; 4969 4970 4971 //class declaration 4972 class vksurfaceformatkhr_struct_wrapper 4973 { 4974 public: 4975 vksurfaceformatkhr_struct_wrapper(); 4976 vksurfaceformatkhr_struct_wrapper(VkSurfaceFormatKHR* pInStruct); 4977 vksurfaceformatkhr_struct_wrapper(const VkSurfaceFormatKHR* pInStruct); 4978 4979 virtual ~vksurfaceformatkhr_struct_wrapper(); 4980 4981 void display_txt(); 4982 void display_single_txt(); 4983 void display_full_txt(); 4984 4985 void set_indent(uint32_t indent) { m_indent = indent; } 4986 VkFormat get_format() { return m_struct.format; } 4987 void set_format(VkFormat inValue) { m_struct.format = inValue; } 4988 VkColorSpaceKHR get_colorSpace() { return m_struct.colorSpace; } 4989 void set_colorSpace(VkColorSpaceKHR inValue) { m_struct.colorSpace = inValue; } 4990 4991 4992 private: 4993 VkSurfaceFormatKHR m_struct; 4994 const VkSurfaceFormatKHR* m_origStructAddr; 4995 uint32_t m_indent; 4996 const char m_dummy_prefix; 4997 void display_struct_members(); 4998 4999 }; 5000 5001 5002 //class declaration 5003 class vkswapchaincreateinfokhr_struct_wrapper 5004 { 5005 public: 5006 vkswapchaincreateinfokhr_struct_wrapper(); 5007 vkswapchaincreateinfokhr_struct_wrapper(VkSwapchainCreateInfoKHR* pInStruct); 5008 vkswapchaincreateinfokhr_struct_wrapper(const VkSwapchainCreateInfoKHR* pInStruct); 5009 5010 virtual ~vkswapchaincreateinfokhr_struct_wrapper(); 5011 5012 void display_txt(); 5013 void display_single_txt(); 5014 void display_full_txt(); 5015 5016 void set_indent(uint32_t indent) { m_indent = indent; } 5017 VkStructureType get_sType() { return m_struct.sType; } 5018 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5019 const void* get_pNext() { return m_struct.pNext; } 5020 VkSwapchainCreateFlagsKHR get_flags() { return m_struct.flags; } 5021 void set_flags(VkSwapchainCreateFlagsKHR inValue) { m_struct.flags = inValue; } 5022 VkSurfaceKHR get_surface() { return m_struct.surface; } 5023 void set_surface(VkSurfaceKHR inValue) { m_struct.surface = inValue; } 5024 uint32_t get_minImageCount() { return m_struct.minImageCount; } 5025 void set_minImageCount(uint32_t inValue) { m_struct.minImageCount = inValue; } 5026 VkFormat get_imageFormat() { return m_struct.imageFormat; } 5027 void set_imageFormat(VkFormat inValue) { m_struct.imageFormat = inValue; } 5028 VkColorSpaceKHR get_imageColorSpace() { return m_struct.imageColorSpace; } 5029 void set_imageColorSpace(VkColorSpaceKHR inValue) { m_struct.imageColorSpace = inValue; } 5030 VkExtent2D get_imageExtent() { return m_struct.imageExtent; } 5031 void set_imageExtent(VkExtent2D inValue) { m_struct.imageExtent = inValue; } 5032 uint32_t get_imageArrayLayers() { return m_struct.imageArrayLayers; } 5033 void set_imageArrayLayers(uint32_t inValue) { m_struct.imageArrayLayers = inValue; } 5034 VkImageUsageFlags get_imageUsage() { return m_struct.imageUsage; } 5035 void set_imageUsage(VkImageUsageFlags inValue) { m_struct.imageUsage = inValue; } 5036 VkSharingMode get_imageSharingMode() { return m_struct.imageSharingMode; } 5037 void set_imageSharingMode(VkSharingMode inValue) { m_struct.imageSharingMode = inValue; } 5038 uint32_t get_queueFamilyIndexCount() { return m_struct.queueFamilyIndexCount; } 5039 void set_queueFamilyIndexCount(uint32_t inValue) { m_struct.queueFamilyIndexCount = inValue; } 5040 VkSurfaceTransformFlagBitsKHR get_preTransform() { return m_struct.preTransform; } 5041 void set_preTransform(VkSurfaceTransformFlagBitsKHR inValue) { m_struct.preTransform = inValue; } 5042 VkCompositeAlphaFlagBitsKHR get_compositeAlpha() { return m_struct.compositeAlpha; } 5043 void set_compositeAlpha(VkCompositeAlphaFlagBitsKHR inValue) { m_struct.compositeAlpha = inValue; } 5044 VkPresentModeKHR get_presentMode() { return m_struct.presentMode; } 5045 void set_presentMode(VkPresentModeKHR inValue) { m_struct.presentMode = inValue; } 5046 VkBool32 get_clipped() { return m_struct.clipped; } 5047 void set_clipped(VkBool32 inValue) { m_struct.clipped = inValue; } 5048 VkSwapchainKHR get_oldSwapchain() { return m_struct.oldSwapchain; } 5049 void set_oldSwapchain(VkSwapchainKHR inValue) { m_struct.oldSwapchain = inValue; } 5050 5051 5052 private: 5053 VkSwapchainCreateInfoKHR m_struct; 5054 const VkSwapchainCreateInfoKHR* m_origStructAddr; 5055 uint32_t m_indent; 5056 const char m_dummy_prefix; 5057 void display_struct_members(); 5058 5059 }; 5060 5061 5062 //class declaration 5063 class vkvalidationflagsext_struct_wrapper 5064 { 5065 public: 5066 vkvalidationflagsext_struct_wrapper(); 5067 vkvalidationflagsext_struct_wrapper(VkValidationFlagsEXT* pInStruct); 5068 vkvalidationflagsext_struct_wrapper(const VkValidationFlagsEXT* pInStruct); 5069 5070 virtual ~vkvalidationflagsext_struct_wrapper(); 5071 5072 void display_txt(); 5073 void display_single_txt(); 5074 void display_full_txt(); 5075 5076 void set_indent(uint32_t indent) { m_indent = indent; } 5077 VkStructureType get_sType() { return m_struct.sType; } 5078 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5079 const void* get_pNext() { return m_struct.pNext; } 5080 uint32_t get_disabledValidationCheckCount() { return m_struct.disabledValidationCheckCount; } 5081 void set_disabledValidationCheckCount(uint32_t inValue) { m_struct.disabledValidationCheckCount = inValue; } 5082 VkValidationCheckEXT* get_pDisabledValidationChecks() { return m_struct.pDisabledValidationChecks; } 5083 void set_pDisabledValidationChecks(VkValidationCheckEXT* inValue) { m_struct.pDisabledValidationChecks = inValue; } 5084 5085 5086 private: 5087 VkValidationFlagsEXT m_struct; 5088 const VkValidationFlagsEXT* m_origStructAddr; 5089 uint32_t m_indent; 5090 const char m_dummy_prefix; 5091 void display_struct_members(); 5092 5093 }; 5094 5095 5096 //class declaration 5097 class vkvertexinputattributedescription_struct_wrapper 5098 { 5099 public: 5100 vkvertexinputattributedescription_struct_wrapper(); 5101 vkvertexinputattributedescription_struct_wrapper(VkVertexInputAttributeDescription* pInStruct); 5102 vkvertexinputattributedescription_struct_wrapper(const VkVertexInputAttributeDescription* pInStruct); 5103 5104 virtual ~vkvertexinputattributedescription_struct_wrapper(); 5105 5106 void display_txt(); 5107 void display_single_txt(); 5108 void display_full_txt(); 5109 5110 void set_indent(uint32_t indent) { m_indent = indent; } 5111 uint32_t get_location() { return m_struct.location; } 5112 void set_location(uint32_t inValue) { m_struct.location = inValue; } 5113 uint32_t get_binding() { return m_struct.binding; } 5114 void set_binding(uint32_t inValue) { m_struct.binding = inValue; } 5115 VkFormat get_format() { return m_struct.format; } 5116 void set_format(VkFormat inValue) { m_struct.format = inValue; } 5117 uint32_t get_offset() { return m_struct.offset; } 5118 void set_offset(uint32_t inValue) { m_struct.offset = inValue; } 5119 5120 5121 private: 5122 VkVertexInputAttributeDescription m_struct; 5123 const VkVertexInputAttributeDescription* m_origStructAddr; 5124 uint32_t m_indent; 5125 const char m_dummy_prefix; 5126 void display_struct_members(); 5127 5128 }; 5129 5130 5131 //class declaration 5132 class vkvertexinputbindingdescription_struct_wrapper 5133 { 5134 public: 5135 vkvertexinputbindingdescription_struct_wrapper(); 5136 vkvertexinputbindingdescription_struct_wrapper(VkVertexInputBindingDescription* pInStruct); 5137 vkvertexinputbindingdescription_struct_wrapper(const VkVertexInputBindingDescription* pInStruct); 5138 5139 virtual ~vkvertexinputbindingdescription_struct_wrapper(); 5140 5141 void display_txt(); 5142 void display_single_txt(); 5143 void display_full_txt(); 5144 5145 void set_indent(uint32_t indent) { m_indent = indent; } 5146 uint32_t get_binding() { return m_struct.binding; } 5147 void set_binding(uint32_t inValue) { m_struct.binding = inValue; } 5148 uint32_t get_stride() { return m_struct.stride; } 5149 void set_stride(uint32_t inValue) { m_struct.stride = inValue; } 5150 VkVertexInputRate get_inputRate() { return m_struct.inputRate; } 5151 void set_inputRate(VkVertexInputRate inValue) { m_struct.inputRate = inValue; } 5152 5153 5154 private: 5155 VkVertexInputBindingDescription m_struct; 5156 const VkVertexInputBindingDescription* m_origStructAddr; 5157 uint32_t m_indent; 5158 const char m_dummy_prefix; 5159 void display_struct_members(); 5160 5161 }; 5162 5163 5164 //class declaration 5165 class vkviewport_struct_wrapper 5166 { 5167 public: 5168 vkviewport_struct_wrapper(); 5169 vkviewport_struct_wrapper(VkViewport* pInStruct); 5170 vkviewport_struct_wrapper(const VkViewport* pInStruct); 5171 5172 virtual ~vkviewport_struct_wrapper(); 5173 5174 void display_txt(); 5175 void display_single_txt(); 5176 void display_full_txt(); 5177 5178 void set_indent(uint32_t indent) { m_indent = indent; } 5179 float get_x() { return m_struct.x; } 5180 void set_x(float inValue) { m_struct.x = inValue; } 5181 float get_y() { return m_struct.y; } 5182 void set_y(float inValue) { m_struct.y = inValue; } 5183 float get_width() { return m_struct.width; } 5184 void set_width(float inValue) { m_struct.width = inValue; } 5185 float get_height() { return m_struct.height; } 5186 void set_height(float inValue) { m_struct.height = inValue; } 5187 float get_minDepth() { return m_struct.minDepth; } 5188 void set_minDepth(float inValue) { m_struct.minDepth = inValue; } 5189 float get_maxDepth() { return m_struct.maxDepth; } 5190 void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; } 5191 5192 5193 private: 5194 VkViewport m_struct; 5195 const VkViewport* m_origStructAddr; 5196 uint32_t m_indent; 5197 const char m_dummy_prefix; 5198 void display_struct_members(); 5199 5200 }; 5201 5202 5203 //class declaration 5204 class vkwaylandsurfacecreateinfokhr_struct_wrapper 5205 { 5206 public: 5207 vkwaylandsurfacecreateinfokhr_struct_wrapper(); 5208 vkwaylandsurfacecreateinfokhr_struct_wrapper(VkWaylandSurfaceCreateInfoKHR* pInStruct); 5209 vkwaylandsurfacecreateinfokhr_struct_wrapper(const VkWaylandSurfaceCreateInfoKHR* pInStruct); 5210 5211 virtual ~vkwaylandsurfacecreateinfokhr_struct_wrapper(); 5212 5213 void display_txt(); 5214 void display_single_txt(); 5215 void display_full_txt(); 5216 5217 void set_indent(uint32_t indent) { m_indent = indent; } 5218 VkStructureType get_sType() { return m_struct.sType; } 5219 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5220 const void* get_pNext() { return m_struct.pNext; } 5221 VkWaylandSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 5222 void set_flags(VkWaylandSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 5223 struct wl_display* get_display() { return m_struct.display; } 5224 void set_display(struct wl_display* inValue) { m_struct.display = inValue; } 5225 struct wl_surface* get_surface() { return m_struct.surface; } 5226 void set_surface(struct wl_surface* inValue) { m_struct.surface = inValue; } 5227 5228 5229 private: 5230 VkWaylandSurfaceCreateInfoKHR m_struct; 5231 const VkWaylandSurfaceCreateInfoKHR* m_origStructAddr; 5232 uint32_t m_indent; 5233 const char m_dummy_prefix; 5234 void display_struct_members(); 5235 5236 }; 5237 5238 5239 //class declaration 5240 class vkwin32keyedmutexacquirereleaseinfonv_struct_wrapper 5241 { 5242 public: 5243 vkwin32keyedmutexacquirereleaseinfonv_struct_wrapper(); 5244 vkwin32keyedmutexacquirereleaseinfonv_struct_wrapper(VkWin32KeyedMutexAcquireReleaseInfoNV* pInStruct); 5245 vkwin32keyedmutexacquirereleaseinfonv_struct_wrapper(const VkWin32KeyedMutexAcquireReleaseInfoNV* pInStruct); 5246 5247 virtual ~vkwin32keyedmutexacquirereleaseinfonv_struct_wrapper(); 5248 5249 void display_txt(); 5250 void display_single_txt(); 5251 void display_full_txt(); 5252 5253 void set_indent(uint32_t indent) { m_indent = indent; } 5254 VkStructureType get_sType() { return m_struct.sType; } 5255 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5256 const void* get_pNext() { return m_struct.pNext; } 5257 uint32_t get_acquireCount() { return m_struct.acquireCount; } 5258 void set_acquireCount(uint32_t inValue) { m_struct.acquireCount = inValue; } 5259 uint32_t get_releaseCount() { return m_struct.releaseCount; } 5260 void set_releaseCount(uint32_t inValue) { m_struct.releaseCount = inValue; } 5261 5262 5263 private: 5264 VkWin32KeyedMutexAcquireReleaseInfoNV m_struct; 5265 const VkWin32KeyedMutexAcquireReleaseInfoNV* m_origStructAddr; 5266 uint32_t m_indent; 5267 const char m_dummy_prefix; 5268 void display_struct_members(); 5269 5270 }; 5271 5272 5273 //class declaration 5274 class vkwin32surfacecreateinfokhr_struct_wrapper 5275 { 5276 public: 5277 vkwin32surfacecreateinfokhr_struct_wrapper(); 5278 vkwin32surfacecreateinfokhr_struct_wrapper(VkWin32SurfaceCreateInfoKHR* pInStruct); 5279 vkwin32surfacecreateinfokhr_struct_wrapper(const VkWin32SurfaceCreateInfoKHR* pInStruct); 5280 5281 virtual ~vkwin32surfacecreateinfokhr_struct_wrapper(); 5282 5283 void display_txt(); 5284 void display_single_txt(); 5285 void display_full_txt(); 5286 5287 void set_indent(uint32_t indent) { m_indent = indent; } 5288 VkStructureType get_sType() { return m_struct.sType; } 5289 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5290 const void* get_pNext() { return m_struct.pNext; } 5291 VkWin32SurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 5292 void set_flags(VkWin32SurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 5293 HINSTANCE get_hinstance() { return m_struct.hinstance; } 5294 void set_hinstance(HINSTANCE inValue) { m_struct.hinstance = inValue; } 5295 HWND get_hwnd() { return m_struct.hwnd; } 5296 void set_hwnd(HWND inValue) { m_struct.hwnd = inValue; } 5297 5298 5299 private: 5300 VkWin32SurfaceCreateInfoKHR m_struct; 5301 const VkWin32SurfaceCreateInfoKHR* m_origStructAddr; 5302 uint32_t m_indent; 5303 const char m_dummy_prefix; 5304 void display_struct_members(); 5305 5306 }; 5307 5308 5309 //class declaration 5310 class vkwritedescriptorset_struct_wrapper 5311 { 5312 public: 5313 vkwritedescriptorset_struct_wrapper(); 5314 vkwritedescriptorset_struct_wrapper(VkWriteDescriptorSet* pInStruct); 5315 vkwritedescriptorset_struct_wrapper(const VkWriteDescriptorSet* pInStruct); 5316 5317 virtual ~vkwritedescriptorset_struct_wrapper(); 5318 5319 void display_txt(); 5320 void display_single_txt(); 5321 void display_full_txt(); 5322 5323 void set_indent(uint32_t indent) { m_indent = indent; } 5324 VkStructureType get_sType() { return m_struct.sType; } 5325 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5326 const void* get_pNext() { return m_struct.pNext; } 5327 VkDescriptorSet get_dstSet() { return m_struct.dstSet; } 5328 void set_dstSet(VkDescriptorSet inValue) { m_struct.dstSet = inValue; } 5329 uint32_t get_dstBinding() { return m_struct.dstBinding; } 5330 void set_dstBinding(uint32_t inValue) { m_struct.dstBinding = inValue; } 5331 uint32_t get_dstArrayElement() { return m_struct.dstArrayElement; } 5332 void set_dstArrayElement(uint32_t inValue) { m_struct.dstArrayElement = inValue; } 5333 uint32_t get_descriptorCount() { return m_struct.descriptorCount; } 5334 void set_descriptorCount(uint32_t inValue) { m_struct.descriptorCount = inValue; } 5335 VkDescriptorType get_descriptorType() { return m_struct.descriptorType; } 5336 void set_descriptorType(VkDescriptorType inValue) { m_struct.descriptorType = inValue; } 5337 5338 5339 private: 5340 VkWriteDescriptorSet m_struct; 5341 const VkWriteDescriptorSet* m_origStructAddr; 5342 uint32_t m_indent; 5343 const char m_dummy_prefix; 5344 void display_struct_members(); 5345 5346 }; 5347 5348 5349 //class declaration 5350 class vkxcbsurfacecreateinfokhr_struct_wrapper 5351 { 5352 public: 5353 vkxcbsurfacecreateinfokhr_struct_wrapper(); 5354 vkxcbsurfacecreateinfokhr_struct_wrapper(VkXcbSurfaceCreateInfoKHR* pInStruct); 5355 vkxcbsurfacecreateinfokhr_struct_wrapper(const VkXcbSurfaceCreateInfoKHR* pInStruct); 5356 5357 virtual ~vkxcbsurfacecreateinfokhr_struct_wrapper(); 5358 5359 void display_txt(); 5360 void display_single_txt(); 5361 void display_full_txt(); 5362 5363 void set_indent(uint32_t indent) { m_indent = indent; } 5364 VkStructureType get_sType() { return m_struct.sType; } 5365 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5366 const void* get_pNext() { return m_struct.pNext; } 5367 VkXcbSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 5368 void set_flags(VkXcbSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 5369 xcb_connection_t* get_connection() { return m_struct.connection; } 5370 void set_connection(xcb_connection_t* inValue) { m_struct.connection = inValue; } 5371 xcb_window_t get_window() { return m_struct.window; } 5372 void set_window(xcb_window_t inValue) { m_struct.window = inValue; } 5373 5374 5375 private: 5376 VkXcbSurfaceCreateInfoKHR m_struct; 5377 const VkXcbSurfaceCreateInfoKHR* m_origStructAddr; 5378 uint32_t m_indent; 5379 const char m_dummy_prefix; 5380 void display_struct_members(); 5381 5382 }; 5383 5384 5385 //class declaration 5386 class vkxlibsurfacecreateinfokhr_struct_wrapper 5387 { 5388 public: 5389 vkxlibsurfacecreateinfokhr_struct_wrapper(); 5390 vkxlibsurfacecreateinfokhr_struct_wrapper(VkXlibSurfaceCreateInfoKHR* pInStruct); 5391 vkxlibsurfacecreateinfokhr_struct_wrapper(const VkXlibSurfaceCreateInfoKHR* pInStruct); 5392 5393 virtual ~vkxlibsurfacecreateinfokhr_struct_wrapper(); 5394 5395 void display_txt(); 5396 void display_single_txt(); 5397 void display_full_txt(); 5398 5399 void set_indent(uint32_t indent) { m_indent = indent; } 5400 VkStructureType get_sType() { return m_struct.sType; } 5401 void set_sType(VkStructureType inValue) { m_struct.sType = inValue; } 5402 const void* get_pNext() { return m_struct.pNext; } 5403 VkXlibSurfaceCreateFlagsKHR get_flags() { return m_struct.flags; } 5404 void set_flags(VkXlibSurfaceCreateFlagsKHR inValue) { m_struct.flags = inValue; } 5405 Display* get_dpy() { return m_struct.dpy; } 5406 void set_dpy(Display* inValue) { m_struct.dpy = inValue; } 5407 Window get_window() { return m_struct.window; } 5408 void set_window(Window inValue) { m_struct.window = inValue; } 5409 5410 5411 private: 5412 VkXlibSurfaceCreateInfoKHR m_struct; 5413 const VkXlibSurfaceCreateInfoKHR* m_origStructAddr; 5414 uint32_t m_indent; 5415 const char m_dummy_prefix; 5416 void display_struct_members(); 5417 5418 }; 5419 5420 //any footer info for class 5421
