diff --git a/tools/glave/scripts/vk_generate.py b/tools/glave/scripts/vk_generate.py
index e96dc7c..bec34ed 100755
--- a/tools/glave/scripts/vk_generate.py
+++ b/tools/glave/scripts/vk_generate.py
@@ -1387,7 +1387,7 @@
         return "\n".join(pid_enum)
 
     # Interpret functions used on replay to read in packets and interpret their contents
-    #  This code gets generated into glvtrace_xgl_xgl_structs.h file
+    #  This code gets generated into glv_vk_vk_structs.h file
     def _generate_interp_funcs(self):
         # Custom txt for given function and parameter.  First check if param is NULL, then insert txt if not
         # TODO : This code is now too large and complex, need to make codegen smarter for pointers embedded in struct params to handle those cases automatically
@@ -3341,8 +3341,8 @@
 class GlaveTraceHeader(Subcommand):
     def generate_header(self):
         header_txt = []
-        header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
-        header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')
+        header_txt.append('#include "glv_vk_vk_structs.h"')
+        header_txt.append('#include "glv_vk_packet_id.h"\n')
         header_txt.append('void AttachHooks();')
         header_txt.append('void DetachHooks();')
         header_txt.append('void InitTracer(void);\n')
@@ -3389,9 +3389,9 @@
         header_txt.append('#include "glv_trace_packet_utils.h"')
         header_txt.append('#include "glv_trace_packet_identifiers.h"')
         header_txt.append('#include "glv_interconnect.h"')
-        header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
-        header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
-        header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
+        header_txt.append('#include "glv_vk_vk_structs.h"')
+        header_txt.append('#include "glv_vk_vkdbg_structs.h"')
+        header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
         header_txt.append('#include "xgl_enum_string_helper.h"')
         header_txt.append('#if defined(WIN32)')
         header_txt.append('#define snprintf _snprintf')
@@ -3455,8 +3455,8 @@
         header_txt.append('#include "glv_platform.h"')
         header_txt.append('#include "glv_common.h"')
         header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
-        header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
-        header_txt.append('#include "glvtrace_xgl_packet_id.h"')
+        header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
+        header_txt.append('#include "glv_vk_packet_id.h"')
         header_txt.append('#ifdef WIN32')
         header_txt.append('#include "mhook/mhook-lib/mhook.h"')
         header_txt.append('#endif')
@@ -3510,8 +3510,8 @@
         header_txt.append('#include "glv_common.h"')
         header_txt.append('#include "glvtrace_xgl_xgl.h"')
         header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
-        header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
-        header_txt.append('#include "glvtrace_xgl_packet_id.h"')
+        header_txt.append('#include "glv_vk_vkdbg_structs.h"')
+        header_txt.append('#include "glv_vk_packet_id.h"')
         header_txt.append('#ifdef WIN32')
         header_txt.append('#include "mhook/mhook-lib/mhook.h"')
         header_txt.append('#endif')
@@ -3581,10 +3581,10 @@
         header_txt.append('#include <queue>')
         header_txt.append('glvreplay_settings *g_pReplaySettings;')
         header_txt.append('extern "C" {')
-        header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
-        header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
-        header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
-        header_txt.append('#include "glvtrace_xgl_packet_id.h"')
+        header_txt.append('#include "glv_vk_vk_structs.h"')
+        header_txt.append('#include "glv_vk_vkdbg_structs.h"')
+        header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
+        header_txt.append('#include "glv_vk_packet_id.h"')
         header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')
         header_txt.append('#define APP_NAME "glvreplay_xgl"')
         header_txt.append('#define IDI_ICON 101\n')
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
index 589cf66..89d5fa9 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
@@ -20,15 +20,15 @@
 
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen)
 
-add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h
+add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen
                    DEPENDS ${SRC_DIR}/../scripts/vk_generate.py
                            ${SRC_DIR}/../../../xgl_helper.py
@@ -75,10 +75,10 @@
 set(HDR_LIST
     glvdebug_xgl_settings.h
     glvdebug_xgl_qgroupframesproxymodel.h
-    codegen/glvtrace_xgl_packet_id.h
-    codegen/glvtrace_xgl_xgl_structs.h
-    codegen/glvtrace_xgl_xglwsix11ext_structs.h
-    codegen/glvtrace_xgl_xgldbg_structs.h
+    codegen/glv_vk_packet_id.h
+    codegen/glv_vk_vk_structs.h
+    codegen/glv_vk_vkwsix11ext_structs.h
+    codegen/glv_vk_vkdbg_structs.h
     ${SRC_DIR}/glvdebug/glvdebug_qgroupthreadsproxymodel.h
     ${SRC_DIR}/glvdebug/glvdebug_controller.h
     ${SRC_DIR}/glvreplay/glvreplay_factory.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h
similarity index 99%
rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h
index d1dded3..d774f98 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h
@@ -29,9 +29,9 @@
 #include "glv_trace_packet_utils.h"
 #include "glv_trace_packet_identifiers.h"
 #include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_vkwsix11ext_structs.h"
 #include "xgl_enum_string_helper.h"
 #if defined(WIN32)
 #define snprintf _snprintf
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vk_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgl_structs.h
rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vk_structs.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkdbg_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgldbg_structs.h
rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkdbg_structs.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkwsix11ext_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h
rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkwsix11ext_structs.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h
index ef9fcd3..1322edf 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h
@@ -3,16 +3,28 @@
 #include <xgl.h>
 
 
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
     {
-        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
-            return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
-        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
-            return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
+        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
         default:
-            return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+            return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+    switch ((XGL_IMAGE_TILING)input_value)
+    {
+        case XGL_LINEAR_TILING:
+            return "XGL_LINEAR_TILING";
+        case XGL_OPTIMAL_TILING:
+            return "XGL_OPTIMAL_TILING";
+        default:
+            return "Unhandled XGL_IMAGE_TILING";
     }
 }
 
@@ -31,234 +43,48 @@
 }
 
 
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
 {
-    switch ((XGL_MEMORY_TYPE)input_value)
+    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
     {
-        case XGL_MEMORY_TYPE_BUFFER:
-            return "XGL_MEMORY_TYPE_BUFFER";
-        case XGL_MEMORY_TYPE_IMAGE:
-            return "XGL_MEMORY_TYPE_IMAGE";
-        case XGL_MEMORY_TYPE_OTHER:
-            return "XGL_MEMORY_TYPE_OTHER";
+        case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+            return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
+        case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+            return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
+        case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_D16:
+            return "XGL_IMAGE_FORMAT_CLASS_D16";
+        case XGL_IMAGE_FORMAT_CLASS_D16S8:
+            return "XGL_IMAGE_FORMAT_CLASS_D16S8";
+        case XGL_IMAGE_FORMAT_CLASS_D24:
+            return "XGL_IMAGE_FORMAT_CLASS_D24";
+        case XGL_IMAGE_FORMAT_CLASS_D24S8:
+            return "XGL_IMAGE_FORMAT_CLASS_D24S8";
+        case XGL_IMAGE_FORMAT_CLASS_D32:
+            return "XGL_IMAGE_FORMAT_CLASS_D32";
+        case XGL_IMAGE_FORMAT_CLASS_D32S8:
+            return "XGL_IMAGE_FORMAT_CLASS_D32S8";
+        case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+            return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
+        case XGL_IMAGE_FORMAT_CLASS_S8:
+            return "XGL_IMAGE_FORMAT_CLASS_S8";
         default:
-            return "Unhandled XGL_MEMORY_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
-    {
-        case XGL_SHADER_STAGE_COMPUTE:
-            return "XGL_SHADER_STAGE_COMPUTE";
-        case XGL_SHADER_STAGE_FRAGMENT:
-            return "XGL_SHADER_STAGE_FRAGMENT";
-        case XGL_SHADER_STAGE_GEOMETRY:
-            return "XGL_SHADER_STAGE_GEOMETRY";
-        case XGL_SHADER_STAGE_TESS_CONTROL:
-            return "XGL_SHADER_STAGE_TESS_CONTROL";
-        case XGL_SHADER_STAGE_TESS_EVALUATION:
-            return "XGL_SHADER_STAGE_TESS_EVALUATION";
-        case XGL_SHADER_STAGE_VERTEX:
-            return "XGL_SHADER_STAGE_VERTEX";
-        default:
-            return "Unhandled XGL_PIPELINE_SHADER_STAGE";
-    }
-}
-
-
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
-    switch ((XGL_CULL_MODE)input_value)
-    {
-        case XGL_CULL_BACK:
-            return "XGL_CULL_BACK";
-        case XGL_CULL_FRONT:
-            return "XGL_CULL_FRONT";
-        case XGL_CULL_FRONT_AND_BACK:
-            return "XGL_CULL_FRONT_AND_BACK";
-        case XGL_CULL_NONE:
-            return "XGL_CULL_NONE";
-        default:
-            return "Unhandled XGL_CULL_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
-    switch ((XGL_IMAGE_LAYOUT)input_value)
-    {
-        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_GENERAL:
-            return "XGL_IMAGE_LAYOUT_GENERAL";
-        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
-        default:
-            return "Unhandled XGL_IMAGE_LAYOUT";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
-    switch ((XGL_MEMORY_PRIORITY)input_value)
-    {
-        case XGL_MEMORY_PRIORITY_HIGH:
-            return "XGL_MEMORY_PRIORITY_HIGH";
-        case XGL_MEMORY_PRIORITY_LOW:
-            return "XGL_MEMORY_PRIORITY_LOW";
-        case XGL_MEMORY_PRIORITY_NORMAL:
-            return "XGL_MEMORY_PRIORITY_NORMAL";
-        case XGL_MEMORY_PRIORITY_UNUSED:
-            return "XGL_MEMORY_PRIORITY_UNUSED";
-        case XGL_MEMORY_PRIORITY_VERY_HIGH:
-            return "XGL_MEMORY_PRIORITY_VERY_HIGH";
-        case XGL_MEMORY_PRIORITY_VERY_LOW:
-            return "XGL_MEMORY_PRIORITY_VERY_LOW";
-        default:
-            return "Unhandled XGL_MEMORY_PRIORITY";
-    }
-}
-
-
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
-    switch ((XGL_QUERY_TYPE)input_value)
-    {
-        case XGL_QUERY_OCCLUSION:
-            return "XGL_QUERY_OCCLUSION";
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return "XGL_QUERY_PIPELINE_STATISTICS";
-        default:
-            return "Unhandled XGL_QUERY_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
-        default:
-            return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
-    switch ((XGL_VALIDATION_LEVEL)input_value)
-    {
-        case XGL_VALIDATION_LEVEL_0:
-            return "XGL_VALIDATION_LEVEL_0";
-        case XGL_VALIDATION_LEVEL_1:
-            return "XGL_VALIDATION_LEVEL_1";
-        case XGL_VALIDATION_LEVEL_2:
-            return "XGL_VALIDATION_LEVEL_2";
-        case XGL_VALIDATION_LEVEL_3:
-            return "XGL_VALIDATION_LEVEL_3";
-        case XGL_VALIDATION_LEVEL_4:
-            return "XGL_VALIDATION_LEVEL_4";
-        default:
-            return "Unhandled XGL_VALIDATION_LEVEL";
-    }
-}
-
-
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
-    switch ((XGL_STATE_BIND_POINT)input_value)
-    {
-        case XGL_STATE_BIND_COLOR_BLEND:
-            return "XGL_STATE_BIND_COLOR_BLEND";
-        case XGL_STATE_BIND_DEPTH_STENCIL:
-            return "XGL_STATE_BIND_DEPTH_STENCIL";
-        case XGL_STATE_BIND_RASTER:
-            return "XGL_STATE_BIND_RASTER";
-        case XGL_STATE_BIND_VIEWPORT:
-            return "XGL_STATE_BIND_VIEWPORT";
-        default:
-            return "Unhandled XGL_STATE_BIND_POINT";
-    }
-}
-
-
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
-    {
-        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
-            return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
-        case XGL_BUFFER_CREATE_SPARSE_BIT:
-            return "XGL_BUFFER_CREATE_SPARSE_BIT";
-        default:
-            return "Unhandled XGL_BUFFER_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
-    {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-            return "XGL_BORDER_COLOR_OPAQUE_BLACK";
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-            return "XGL_BORDER_COLOR_OPAQUE_WHITE";
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
-            return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
-        default:
-            return "Unhandled XGL_BORDER_COLOR_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
-    {
-        case XGL_BUFFER_VIEW_RAW:
-            return "XGL_BUFFER_VIEW_RAW";
-        case XGL_BUFFER_VIEW_STRUCTURED:
-            return "XGL_BUFFER_VIEW_STRUCTURED";
-        case XGL_BUFFER_VIEW_TYPED:
-            return "XGL_BUFFER_VIEW_TYPED";
-        default:
-            return "Unhandled XGL_BUFFER_VIEW_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
-        default:
-            return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+            return "Unhandled XGL_IMAGE_FORMAT_CLASS";
     }
 }
 
@@ -293,74 +119,72 @@
 }
 
 
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
 {
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
     {
-        case XGL_QUERY_IMPRECISE_DATA_BIT:
-            return "XGL_QUERY_IMPRECISE_DATA_BIT";
+        case XGL_IMAGE_VIEW_1D:
+            return "XGL_IMAGE_VIEW_1D";
+        case XGL_IMAGE_VIEW_2D:
+            return "XGL_IMAGE_VIEW_2D";
+        case XGL_IMAGE_VIEW_3D:
+            return "XGL_IMAGE_VIEW_3D";
+        case XGL_IMAGE_VIEW_CUBE:
+            return "XGL_IMAGE_VIEW_CUBE";
         default:
-            return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+            return "Unhandled XGL_IMAGE_VIEW_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
 {
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
     {
-        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
-            return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
-        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
-            return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
-        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
-            return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
-        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
-            return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
-        case XGL_IMAGE_CREATE_SPARSE_BIT:
-            return "XGL_IMAGE_CREATE_SPARSE_BIT";
+        case XGL_GPU_TYPE_DISCRETE:
+            return "XGL_GPU_TYPE_DISCRETE";
+        case XGL_GPU_TYPE_INTEGRATED:
+            return "XGL_GPU_TYPE_INTEGRATED";
+        case XGL_GPU_TYPE_OTHER:
+            return "XGL_GPU_TYPE_OTHER";
+        case XGL_GPU_TYPE_VIRTUAL:
+            return "XGL_GPU_TYPE_VIRTUAL";
         default:
-            return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+            return "Unhandled XGL_PHYSICAL_GPU_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 {
-    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+    switch ((XGL_QUERY_TYPE)input_value)
     {
-        case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
-            return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
-        case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
-            return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
-        case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
-            return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
+        case XGL_QUERY_OCCLUSION:
+            return "XGL_QUERY_OCCLUSION";
+        case XGL_QUERY_PIPELINE_STATISTICS:
+            return "XGL_QUERY_PIPELINE_STATISTICS";
         default:
-            return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
+            return "Unhandled XGL_QUERY_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
 {
-    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
     {
-        case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
-            return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
-        case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
-            return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
-        case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
-            return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
-        case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
-            return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
-        case XGL_MEMORY_PROPERTY_GPU_ONLY:
-            return "XGL_MEMORY_PROPERTY_GPU_ONLY";
-        case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
-            return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
-        case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
-            return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
+        case XGL_SYSTEM_ALLOC_API_OBJECT:
+            return "XGL_SYSTEM_ALLOC_API_OBJECT";
+        case XGL_SYSTEM_ALLOC_DEBUG:
+            return "XGL_SYSTEM_ALLOC_DEBUG";
+        case XGL_SYSTEM_ALLOC_INTERNAL:
+            return "XGL_SYSTEM_ALLOC_INTERNAL";
+        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+            return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+            return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
         default:
-            return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
+            return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
     }
 }
 
@@ -391,124 +215,262 @@
 }
 
 
-static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
 {
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
     {
-        case XGL_PIPELINE_BIND_POINT_COMPUTE:
-            return "XGL_PIPELINE_BIND_POINT_COMPUTE";
-        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
-            return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
+        case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+            return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
+        case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+            return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
+        case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+            return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
         default:
-            return "Unhandled XGL_PIPELINE_BIND_POINT";
+            return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
     }
 }
 
 
-static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
 {
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
     {
-        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
+        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+            return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+            return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+            return "XGL_ATTACHMENT_LOAD_OP_LOAD";
         default:
-            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
     }
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 {
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    switch ((XGL_IMAGE_ASPECT)input_value)
     {
-        case XGL_DESCRIPTOR_TYPE_IMAGE:
-            return "XGL_DESCRIPTOR_TYPE_IMAGE";
-        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
-        case XGL_DESCRIPTOR_TYPE_SAMPLER:
-            return "XGL_DESCRIPTOR_TYPE_SAMPLER";
-        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
-            return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
-        case XGL_DESCRIPTOR_TYPE_TEXTURE:
-            return "XGL_DESCRIPTOR_TYPE_TEXTURE";
-        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+        case XGL_IMAGE_ASPECT_COLOR:
+            return "XGL_IMAGE_ASPECT_COLOR";
+        case XGL_IMAGE_ASPECT_DEPTH:
+            return "XGL_IMAGE_ASPECT_DEPTH";
+        case XGL_IMAGE_ASPECT_STENCIL:
+            return "XGL_IMAGE_ASPECT_STENCIL";
         default:
-            return "Unhandled XGL_DESCRIPTOR_TYPE";
+            return "Unhandled XGL_IMAGE_ASPECT";
     }
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
     {
-        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
-            return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
-        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
-            return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+            return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
+        case XGL_BUFFER_CREATE_SPARSE_BIT:
+            return "XGL_BUFFER_CREATE_SPARSE_BIT";
         default:
-            return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+            return "Unhandled XGL_BUFFER_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
     {
-        case XGL_CHANNEL_SWIZZLE_A:
-            return "XGL_CHANNEL_SWIZZLE_A";
-        case XGL_CHANNEL_SWIZZLE_B:
-            return "XGL_CHANNEL_SWIZZLE_B";
-        case XGL_CHANNEL_SWIZZLE_G:
-            return "XGL_CHANNEL_SWIZZLE_G";
-        case XGL_CHANNEL_SWIZZLE_ONE:
-            return "XGL_CHANNEL_SWIZZLE_ONE";
-        case XGL_CHANNEL_SWIZZLE_R:
-            return "XGL_CHANNEL_SWIZZLE_R";
-        case XGL_CHANNEL_SWIZZLE_ZERO:
-            return "XGL_CHANNEL_SWIZZLE_ZERO";
+        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+            return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+            return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+            return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+            return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
         default:
-            return "Unhandled XGL_CHANNEL_SWIZZLE";
+            return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
 {
-    switch ((XGL_TEX_ADDRESS)input_value)
+    switch ((XGL_FACE_ORIENTATION)input_value)
     {
-        case XGL_TEX_ADDRESS_CLAMP:
-            return "XGL_TEX_ADDRESS_CLAMP";
-        case XGL_TEX_ADDRESS_CLAMP_BORDER:
-            return "XGL_TEX_ADDRESS_CLAMP_BORDER";
-        case XGL_TEX_ADDRESS_MIRROR:
-            return "XGL_TEX_ADDRESS_MIRROR";
-        case XGL_TEX_ADDRESS_MIRROR_ONCE:
-            return "XGL_TEX_ADDRESS_MIRROR_ONCE";
-        case XGL_TEX_ADDRESS_WRAP:
-            return "XGL_TEX_ADDRESS_WRAP";
+        case XGL_FRONT_FACE_CCW:
+            return "XGL_FRONT_FACE_CCW";
+        case XGL_FRONT_FACE_CW:
+            return "XGL_FRONT_FACE_CW";
         default:
-            return "Unhandled XGL_TEX_ADDRESS";
+            return "Unhandled XGL_FACE_ORIENTATION";
+    }
+}
+
+
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+    switch ((XGL_TEX_FILTER)input_value)
+    {
+        case XGL_TEX_FILTER_LINEAR:
+            return "XGL_TEX_FILTER_LINEAR";
+        case XGL_TEX_FILTER_NEAREST:
+            return "XGL_TEX_FILTER_NEAREST";
+        default:
+            return "Unhandled XGL_TEX_FILTER";
+    }
+}
+
+
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    {
+        case XGL_BUFFER_VIEW_RAW:
+            return "XGL_BUFFER_VIEW_RAW";
+        case XGL_BUFFER_VIEW_STRUCTURED:
+            return "XGL_BUFFER_VIEW_STRUCTURED";
+        case XGL_BUFFER_VIEW_TYPED:
+            return "XGL_BUFFER_VIEW_TYPED";
+        default:
+            return "Unhandled XGL_BUFFER_VIEW_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    {
+        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+        default:
+            return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
+        default:
+            return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+    switch ((XGL_QUEUE_TYPE)input_value)
+    {
+        case XGL_QUEUE_TYPE_COMPUTE:
+            return "XGL_QUEUE_TYPE_COMPUTE";
+        case XGL_QUEUE_TYPE_DMA:
+            return "XGL_QUEUE_TYPE_DMA";
+        case XGL_QUEUE_TYPE_GRAPHICS:
+            return "XGL_QUEUE_TYPE_GRAPHICS";
+        default:
+            return "Unhandled XGL_QUEUE_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    {
+        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+            return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+            return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+    }
+}
+
+
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+    switch ((XGL_COORDINATE_ORIGIN)input_value)
+    {
+        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+            return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+            return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+        default:
+            return "Unhandled XGL_COORDINATE_ORIGIN";
+    }
+}
+
+
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+    switch ((XGL_FILL_MODE)input_value)
+    {
+        case XGL_FILL_POINTS:
+            return "XGL_FILL_POINTS";
+        case XGL_FILL_SOLID:
+            return "XGL_FILL_SOLID";
+        case XGL_FILL_WIREFRAME:
+            return "XGL_FILL_WIREFRAME";
+        default:
+            return "Unhandled XGL_FILL_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+    switch ((XGL_WAIT_EVENT)input_value)
+    {
+        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+            return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
+        case XGL_WAIT_EVENT_TOP_OF_PIPE:
+            return "XGL_WAIT_EVENT_TOP_OF_PIPE";
+        default:
+            return "Unhandled XGL_WAIT_EVENT";
+    }
+}
+
+
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+    switch ((XGL_STENCIL_OP)input_value)
+    {
+        case XGL_STENCIL_OP_DEC_CLAMP:
+            return "XGL_STENCIL_OP_DEC_CLAMP";
+        case XGL_STENCIL_OP_DEC_WRAP:
+            return "XGL_STENCIL_OP_DEC_WRAP";
+        case XGL_STENCIL_OP_INC_CLAMP:
+            return "XGL_STENCIL_OP_INC_CLAMP";
+        case XGL_STENCIL_OP_INC_WRAP:
+            return "XGL_STENCIL_OP_INC_WRAP";
+        case XGL_STENCIL_OP_INVERT:
+            return "XGL_STENCIL_OP_INVERT";
+        case XGL_STENCIL_OP_KEEP:
+            return "XGL_STENCIL_OP_KEEP";
+        case XGL_STENCIL_OP_REPLACE:
+            return "XGL_STENCIL_OP_REPLACE";
+        case XGL_STENCIL_OP_ZERO:
+            return "XGL_STENCIL_OP_ZERO";
+        default:
+            return "Unhandled XGL_STENCIL_OP";
     }
 }
 
@@ -551,428 +513,52 @@
 }
 
 
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 {
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    switch ((XGL_BLEND_FUNC)input_value)
     {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-            return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
-            return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+        case XGL_BLEND_FUNC_ADD:
+            return "XGL_BLEND_FUNC_ADD";
+        case XGL_BLEND_FUNC_MAX:
+            return "XGL_BLEND_FUNC_MAX";
+        case XGL_BLEND_FUNC_MIN:
+            return "XGL_BLEND_FUNC_MIN";
+        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+            return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+        case XGL_BLEND_FUNC_SUBTRACT:
+            return "XGL_BLEND_FUNC_SUBTRACT";
         default:
-            return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+            return "Unhandled XGL_BLEND_FUNC";
     }
 }
 
 
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
 {
-    switch ((XGL_QUEUE_FLAGS)input_value)
+    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
     {
-        case XGL_QUEUE_COMPUTE_BIT:
-            return "XGL_QUEUE_COMPUTE_BIT";
-        case XGL_QUEUE_DMA_BIT:
-            return "XGL_QUEUE_DMA_BIT";
-        case XGL_QUEUE_EXTENDED_BIT:
-            return "XGL_QUEUE_EXTENDED_BIT";
-        case XGL_QUEUE_GRAPHICS_BIT:
-            return "XGL_QUEUE_GRAPHICS_BIT";
+        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+            return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+            return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+        case XGL_IMAGE_USAGE_GENERAL:
+            return "XGL_IMAGE_USAGE_GENERAL";
+        case XGL_IMAGE_USAGE_IMAGE_BIT:
+            return "XGL_IMAGE_USAGE_IMAGE_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+        case XGL_IMAGE_USAGE_TEXTURE_BIT:
+            return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+            return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+            return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
         default:
-            return "Unhandled XGL_QUEUE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
-    {
-        case XGL_IMAGE_VIEW_1D:
-            return "XGL_IMAGE_VIEW_1D";
-        case XGL_IMAGE_VIEW_2D:
-            return "XGL_IMAGE_VIEW_2D";
-        case XGL_IMAGE_VIEW_3D:
-            return "XGL_IMAGE_VIEW_3D";
-        case XGL_IMAGE_VIEW_CUBE:
-            return "XGL_IMAGE_VIEW_CUBE";
-        default:
-            return "Unhandled XGL_IMAGE_VIEW_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
-    {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
-        default:
-            return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
-    {
-        case XGL_MEMORY_REF_READ_ONLY_BIT:
-            return "XGL_MEMORY_REF_READ_ONLY_BIT";
-        default:
-            return "Unhandled XGL_MEMORY_REF_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
-    switch ((XGL_STRUCTURE_TYPE)input_value)
-    {
-        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
-            return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
-        case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
-            return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
-        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
-            return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
-        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
-            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
-            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
-        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
-            return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
-        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
-            return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
-            return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
-            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
-            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
-            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
-        case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
-            return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
-        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
-            return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
-        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
-            return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
-        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
-            return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
-        case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
-            return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-            return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-            return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-            return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
-        default:
-            return "Unhandled XGL_STRUCTURE_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
-{
-    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
-    {
-        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
-            return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
-        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
-            return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
-        case XGL_ATTACHMENT_STORE_OP_STORE:
-            return "XGL_ATTACHMENT_STORE_OP_STORE";
-        default:
-            return "Unhandled XGL_ATTACHMENT_STORE_OP";
-    }
-}
-
-
-static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
-    switch ((XGL_WAIT_EVENT)input_value)
-    {
-        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
-            return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
-        case XGL_WAIT_EVENT_TOP_OF_PIPE:
-            return "XGL_WAIT_EVENT_TOP_OF_PIPE";
-        default:
-            return "Unhandled XGL_WAIT_EVENT";
-    }
-}
-
-
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
-    switch ((XGL_DEPTH_MODE)input_value)
-    {
-        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
-            return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
-        case XGL_DEPTH_MODE_ZERO_TO_ONE:
-            return "XGL_DEPTH_MODE_ZERO_TO_ONE";
-        default:
-            return "Unhandled XGL_DEPTH_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
-    switch ((XGL_FILL_MODE)input_value)
-    {
-        case XGL_FILL_POINTS:
-            return "XGL_FILL_POINTS";
-        case XGL_FILL_SOLID:
-            return "XGL_FILL_SOLID";
-        case XGL_FILL_WIREFRAME:
-            return "XGL_FILL_WIREFRAME";
-        default:
-            return "Unhandled XGL_FILL_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
-    {
-        case XGL_TEX_MIPMAP_BASE:
-            return "XGL_TEX_MIPMAP_BASE";
-        case XGL_TEX_MIPMAP_LINEAR:
-            return "XGL_TEX_MIPMAP_LINEAR";
-        case XGL_TEX_MIPMAP_NEAREST:
-            return "XGL_TEX_MIPMAP_NEAREST";
-        default:
-            return "Unhandled XGL_TEX_MIPMAP_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
-    switch ((XGL_SET_EVENT)input_value)
-    {
-        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
-            return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
-        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
-            return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
-        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
-            return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
-        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
-            return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
-        case XGL_SET_EVENT_TOP_OF_PIPE:
-            return "XGL_SET_EVENT_TOP_OF_PIPE";
-        case XGL_SET_EVENT_TRANSFER_COMPLETE:
-            return "XGL_SET_EVENT_TRANSFER_COMPLETE";
-        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
-            return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
-        default:
-            return "Unhandled XGL_SET_EVENT";
-    }
-}
-
-
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
-    switch ((XGL_COORDINATE_ORIGIN)input_value)
-    {
-        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
-            return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
-        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
-            return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
-        default:
-            return "Unhandled XGL_COORDINATE_ORIGIN";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
-    switch ((XGL_IMAGE_ASPECT)input_value)
-    {
-        case XGL_IMAGE_ASPECT_COLOR:
-            return "XGL_IMAGE_ASPECT_COLOR";
-        case XGL_IMAGE_ASPECT_DEPTH:
-            return "XGL_IMAGE_ASPECT_DEPTH";
-        case XGL_IMAGE_ASPECT_STENCIL:
-            return "XGL_IMAGE_ASPECT_STENCIL";
-        default:
-            return "Unhandled XGL_IMAGE_ASPECT";
-    }
-}
-
-
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
-        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
-        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
-            return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
-        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
-        default:
-            return "Unhandled XGL_OBJECT_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
-    {
-        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
-            return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
-        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
-            return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
-        default:
-            return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
-    }
-}
-
-
-static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
-    switch ((XGL_INDEX_TYPE)input_value)
-    {
-        case XGL_INDEX_16:
-            return "XGL_INDEX_16";
-        case XGL_INDEX_32:
-            return "XGL_INDEX_32";
-        case XGL_INDEX_8:
-            return "XGL_INDEX_8";
-        default:
-            return "Unhandled XGL_INDEX_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
-{
-    switch ((XGL_IMAGE_TILING)input_value)
-    {
-        case XGL_LINEAR_TILING:
-            return "XGL_LINEAR_TILING";
-        case XGL_OPTIMAL_TILING:
-            return "XGL_OPTIMAL_TILING";
-        default:
-            return "Unhandled XGL_IMAGE_TILING";
-    }
-}
-
-
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
-{
-    switch ((XGL_QUEUE_TYPE)input_value)
-    {
-        case XGL_QUEUE_TYPE_COMPUTE:
-            return "XGL_QUEUE_TYPE_COMPUTE";
-        case XGL_QUEUE_TYPE_DMA:
-            return "XGL_QUEUE_TYPE_DMA";
-        case XGL_QUEUE_TYPE_GRAPHICS:
-            return "XGL_QUEUE_TYPE_GRAPHICS";
-        default:
-            return "Unhandled XGL_QUEUE_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
-{
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
-    {
-        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
-            return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
-        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
-            return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
-        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
-            return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
-        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
-        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
-        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
-        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
-            return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
-        default:
-            return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+            return "Unhandled XGL_IMAGE_USAGE_FLAGS";
     }
 }
 
@@ -1001,104 +587,336 @@
 }
 
 
-static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
 {
-    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+    switch ((XGL_TEX_MIPMAP_MODE)input_value)
     {
-        case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
-            return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
-        case XGL_MEMORY_INPUT_COPY_BIT:
-            return "XGL_MEMORY_INPUT_COPY_BIT";
-        case XGL_MEMORY_INPUT_CPU_READ_BIT:
-            return "XGL_MEMORY_INPUT_CPU_READ_BIT";
-        case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-            return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
-        case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
-            return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
-        case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
-            return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
-        case XGL_MEMORY_INPUT_SHADER_READ_BIT:
-            return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
-        case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
-            return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
-        case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
-            return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
+        case XGL_TEX_MIPMAP_BASE:
+            return "XGL_TEX_MIPMAP_BASE";
+        case XGL_TEX_MIPMAP_LINEAR:
+            return "XGL_TEX_MIPMAP_LINEAR";
+        case XGL_TEX_MIPMAP_NEAREST:
+            return "XGL_TEX_MIPMAP_NEAREST";
         default:
-            return "Unhandled XGL_MEMORY_INPUT_FLAGS";
+            return "Unhandled XGL_TEX_MIPMAP_MODE";
     }
 }
 
 
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
 {
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    switch ((XGL_RESULT)input_value)
     {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
-            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+        case XGL_ERROR_BAD_PIPELINE_DATA:
+            return "XGL_ERROR_BAD_PIPELINE_DATA";
+        case XGL_ERROR_BAD_SHADER_CODE:
+            return "XGL_ERROR_BAD_SHADER_CODE";
+        case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+            return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
+        case XGL_ERROR_DEVICE_ALREADY_CREATED:
+            return "XGL_ERROR_DEVICE_ALREADY_CREATED";
+        case XGL_ERROR_DEVICE_LOST:
+            return "XGL_ERROR_DEVICE_LOST";
+        case XGL_ERROR_INCOMPATIBLE_DEVICE:
+            return "XGL_ERROR_INCOMPATIBLE_DEVICE";
+        case XGL_ERROR_INCOMPATIBLE_DRIVER:
+            return "XGL_ERROR_INCOMPATIBLE_DRIVER";
+        case XGL_ERROR_INCOMPATIBLE_QUEUE:
+            return "XGL_ERROR_INCOMPATIBLE_QUEUE";
+        case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+            return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
+        case XGL_ERROR_INITIALIZATION_FAILED:
+            return "XGL_ERROR_INITIALIZATION_FAILED";
+        case XGL_ERROR_INVALID_ALIGNMENT:
+            return "XGL_ERROR_INVALID_ALIGNMENT";
+        case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+            return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
+        case XGL_ERROR_INVALID_EXTENSION:
+            return "XGL_ERROR_INVALID_EXTENSION";
+        case XGL_ERROR_INVALID_FLAGS:
+            return "XGL_ERROR_INVALID_FLAGS";
+        case XGL_ERROR_INVALID_FORMAT:
+            return "XGL_ERROR_INVALID_FORMAT";
+        case XGL_ERROR_INVALID_HANDLE:
+            return "XGL_ERROR_INVALID_HANDLE";
+        case XGL_ERROR_INVALID_IMAGE:
+            return "XGL_ERROR_INVALID_IMAGE";
+        case XGL_ERROR_INVALID_MEMORY_SIZE:
+            return "XGL_ERROR_INVALID_MEMORY_SIZE";
+        case XGL_ERROR_INVALID_OBJECT_TYPE:
+            return "XGL_ERROR_INVALID_OBJECT_TYPE";
+        case XGL_ERROR_INVALID_ORDINAL:
+            return "XGL_ERROR_INVALID_ORDINAL";
+        case XGL_ERROR_INVALID_POINTER:
+            return "XGL_ERROR_INVALID_POINTER";
+        case XGL_ERROR_INVALID_QUEUE_TYPE:
+            return "XGL_ERROR_INVALID_QUEUE_TYPE";
+        case XGL_ERROR_INVALID_VALUE:
+            return "XGL_ERROR_INVALID_VALUE";
+        case XGL_ERROR_MEMORY_MAP_FAILED:
+            return "XGL_ERROR_MEMORY_MAP_FAILED";
+        case XGL_ERROR_MEMORY_NOT_BOUND:
+            return "XGL_ERROR_MEMORY_NOT_BOUND";
+        case XGL_ERROR_MEMORY_UNMAP_FAILED:
+            return "XGL_ERROR_MEMORY_UNMAP_FAILED";
+        case XGL_ERROR_NOT_MAPPABLE:
+            return "XGL_ERROR_NOT_MAPPABLE";
+        case XGL_ERROR_NOT_SHAREABLE:
+            return "XGL_ERROR_NOT_SHAREABLE";
+        case XGL_ERROR_OUT_OF_GPU_MEMORY:
+            return "XGL_ERROR_OUT_OF_GPU_MEMORY";
+        case XGL_ERROR_OUT_OF_MEMORY:
+            return "XGL_ERROR_OUT_OF_MEMORY";
+        case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+            return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
+        case XGL_ERROR_UNAVAILABLE:
+            return "XGL_ERROR_UNAVAILABLE";
+        case XGL_ERROR_UNKNOWN:
+            return "XGL_ERROR_UNKNOWN";
+        case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+            return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
+        case XGL_EVENT_RESET:
+            return "XGL_EVENT_RESET";
+        case XGL_EVENT_SET:
+            return "XGL_EVENT_SET";
+        case XGL_NOT_READY:
+            return "XGL_NOT_READY";
+        case XGL_SUCCESS:
+            return "XGL_SUCCESS";
+        case XGL_TIMEOUT:
+            return "XGL_TIMEOUT";
+        case XGL_UNSUPPORTED:
+            return "XGL_UNSUPPORTED";
         default:
-            return "Unhandled XGL_FORMAT_INFO_TYPE";
+            return "Unhandled XGL_RESULT";
     }
 }
 
 
-static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
 {
-    switch ((XGL_LOGIC_OP)input_value)
+    switch ((XGL_SET_EVENT)input_value)
     {
-        case XGL_LOGIC_OP_AND:
-            return "XGL_LOGIC_OP_AND";
-        case XGL_LOGIC_OP_AND_INVERTED:
-            return "XGL_LOGIC_OP_AND_INVERTED";
-        case XGL_LOGIC_OP_AND_REVERSE:
-            return "XGL_LOGIC_OP_AND_REVERSE";
-        case XGL_LOGIC_OP_CLEAR:
-            return "XGL_LOGIC_OP_CLEAR";
-        case XGL_LOGIC_OP_COPY:
-            return "XGL_LOGIC_OP_COPY";
-        case XGL_LOGIC_OP_COPY_INVERTED:
-            return "XGL_LOGIC_OP_COPY_INVERTED";
-        case XGL_LOGIC_OP_EQUIV:
-            return "XGL_LOGIC_OP_EQUIV";
-        case XGL_LOGIC_OP_INVERT:
-            return "XGL_LOGIC_OP_INVERT";
-        case XGL_LOGIC_OP_NAND:
-            return "XGL_LOGIC_OP_NAND";
-        case XGL_LOGIC_OP_NOOP:
-            return "XGL_LOGIC_OP_NOOP";
-        case XGL_LOGIC_OP_NOR:
-            return "XGL_LOGIC_OP_NOR";
-        case XGL_LOGIC_OP_OR:
-            return "XGL_LOGIC_OP_OR";
-        case XGL_LOGIC_OP_OR_INVERTED:
-            return "XGL_LOGIC_OP_OR_INVERTED";
-        case XGL_LOGIC_OP_OR_REVERSE:
-            return "XGL_LOGIC_OP_OR_REVERSE";
-        case XGL_LOGIC_OP_SET:
-            return "XGL_LOGIC_OP_SET";
-        case XGL_LOGIC_OP_XOR:
-            return "XGL_LOGIC_OP_XOR";
+        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+            return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
+        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+            return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+            return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
+        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+            return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+        case XGL_SET_EVENT_TOP_OF_PIPE:
+            return "XGL_SET_EVENT_TOP_OF_PIPE";
+        case XGL_SET_EVENT_TRANSFER_COMPLETE:
+            return "XGL_SET_EVENT_TRANSFER_COMPLETE";
+        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+            return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
         default:
-            return "Unhandled XGL_LOGIC_OP";
+            return "Unhandled XGL_SET_EVENT";
     }
 }
 
 
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_STATE_BIND_POINT)input_value)
     {
-        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
-            return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
-        case XGL_MEMORY_OUTPUT_COPY_BIT:
-            return "XGL_MEMORY_OUTPUT_COPY_BIT";
-        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
-            return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
-        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-            return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
-        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
-            return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+        case XGL_STATE_BIND_COLOR_BLEND:
+            return "XGL_STATE_BIND_COLOR_BLEND";
+        case XGL_STATE_BIND_DEPTH_STENCIL:
+            return "XGL_STATE_BIND_DEPTH_STENCIL";
+        case XGL_STATE_BIND_RASTER:
+            return "XGL_STATE_BIND_RASTER";
+        case XGL_STATE_BIND_VIEWPORT:
+            return "XGL_STATE_BIND_VIEWPORT";
         default:
-            return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+            return "Unhandled XGL_STATE_BIND_POINT";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+    switch ((XGL_IMAGE_LAYOUT)input_value)
+    {
+        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_GENERAL:
+            return "XGL_IMAGE_LAYOUT_GENERAL";
+        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+        default:
+            return "Unhandled XGL_IMAGE_LAYOUT";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    {
+        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+            return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+            return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+    switch ((XGL_MEMORY_TYPE)input_value)
+    {
+        case XGL_MEMORY_TYPE_BUFFER:
+            return "XGL_MEMORY_TYPE_BUFFER";
+        case XGL_MEMORY_TYPE_IMAGE:
+            return "XGL_MEMORY_TYPE_IMAGE";
+        case XGL_MEMORY_TYPE_OTHER:
+            return "XGL_MEMORY_TYPE_OTHER";
+        default:
+            return "Unhandled XGL_MEMORY_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+    switch ((XGL_CULL_MODE)input_value)
+    {
+        case XGL_CULL_BACK:
+            return "XGL_CULL_BACK";
+        case XGL_CULL_FRONT:
+            return "XGL_CULL_FRONT";
+        case XGL_CULL_FRONT_AND_BACK:
+            return "XGL_CULL_FRONT_AND_BACK";
+        case XGL_CULL_NONE:
+            return "XGL_CULL_NONE";
+        default:
+            return "Unhandled XGL_CULL_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+        default:
+            return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_REF_FLAGS)input_value)
+    {
+        case XGL_MEMORY_REF_READ_ONLY_BIT:
+            return "XGL_MEMORY_REF_READ_ONLY_BIT";
+        default:
+            return "Unhandled XGL_MEMORY_REF_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    {
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
+            return "XGL_QUERY_IMPRECISE_DATA_BIT";
+        default:
+            return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+    {
+        case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+            return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
+        case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+            return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
+        case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+            return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
+        case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+            return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
+        case XGL_MEMORY_PROPERTY_GPU_ONLY:
+            return "XGL_MEMORY_PROPERTY_GPU_ONLY";
+        case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+            return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
+        case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+            return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
+        default:
+            return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+{
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
+    {
+        case XGL_TIMESTAMP_BOTTOM:
+            return "XGL_TIMESTAMP_BOTTOM";
+        case XGL_TIMESTAMP_TOP:
+            return "XGL_TIMESTAMP_TOP";
+        default:
+            return "Unhandled XGL_TIMESTAMP_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+    switch ((XGL_IMAGE_TYPE)input_value)
+    {
+        case XGL_IMAGE_1D:
+            return "XGL_IMAGE_1D";
+        case XGL_IMAGE_2D:
+            return "XGL_IMAGE_2D";
+        case XGL_IMAGE_3D:
+            return "XGL_IMAGE_3D";
+        default:
+            return "Unhandled XGL_IMAGE_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    {
+        case XGL_SHADER_STAGE_COMPUTE:
+            return "XGL_SHADER_STAGE_COMPUTE";
+        case XGL_SHADER_STAGE_FRAGMENT:
+            return "XGL_SHADER_STAGE_FRAGMENT";
+        case XGL_SHADER_STAGE_GEOMETRY:
+            return "XGL_SHADER_STAGE_GEOMETRY";
+        case XGL_SHADER_STAGE_TESS_CONTROL:
+            return "XGL_SHADER_STAGE_TESS_CONTROL";
+        case XGL_SHADER_STAGE_TESS_EVALUATION:
+            return "XGL_SHADER_STAGE_TESS_EVALUATION";
+        case XGL_SHADER_STAGE_VERTEX:
+            return "XGL_SHADER_STAGE_VERTEX";
+        default:
+            return "Unhandled XGL_PIPELINE_SHADER_STAGE";
     }
 }
 
@@ -1151,50 +969,160 @@
 }
 
 
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
     {
-        case XGL_GPU_TYPE_DISCRETE:
-            return "XGL_GPU_TYPE_DISCRETE";
-        case XGL_GPU_TYPE_INTEGRATED:
-            return "XGL_GPU_TYPE_INTEGRATED";
-        case XGL_GPU_TYPE_OTHER:
-            return "XGL_GPU_TYPE_OTHER";
-        case XGL_GPU_TYPE_VIRTUAL:
-            return "XGL_GPU_TYPE_VIRTUAL";
+        case XGL_TOPOLOGY_LINE_LIST:
+            return "XGL_TOPOLOGY_LINE_LIST";
+        case XGL_TOPOLOGY_LINE_LIST_ADJ:
+            return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+        case XGL_TOPOLOGY_LINE_STRIP:
+            return "XGL_TOPOLOGY_LINE_STRIP";
+        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+            return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+        case XGL_TOPOLOGY_PATCH:
+            return "XGL_TOPOLOGY_PATCH";
+        case XGL_TOPOLOGY_POINT_LIST:
+            return "XGL_TOPOLOGY_POINT_LIST";
+        case XGL_TOPOLOGY_QUAD_LIST:
+            return "XGL_TOPOLOGY_QUAD_LIST";
+        case XGL_TOPOLOGY_QUAD_STRIP:
+            return "XGL_TOPOLOGY_QUAD_STRIP";
+        case XGL_TOPOLOGY_RECT_LIST:
+            return "XGL_TOPOLOGY_RECT_LIST";
+        case XGL_TOPOLOGY_TRIANGLE_LIST:
+            return "XGL_TOPOLOGY_TRIANGLE_LIST";
+        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+            return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+        case XGL_TOPOLOGY_TRIANGLE_STRIP:
+            return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+            return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
         default:
-            return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+            return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
 {
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+    switch ((XGL_VALIDATION_LEVEL)input_value)
     {
-        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
-            return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
-        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
-            return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
-        case XGL_IMAGE_USAGE_GENERAL:
-            return "XGL_IMAGE_USAGE_GENERAL";
-        case XGL_IMAGE_USAGE_IMAGE_BIT:
-            return "XGL_IMAGE_USAGE_IMAGE_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
-        case XGL_IMAGE_USAGE_TEXTURE_BIT:
-            return "XGL_IMAGE_USAGE_TEXTURE_BIT";
-        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
-            return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
-        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
-            return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
+        case XGL_VALIDATION_LEVEL_0:
+            return "XGL_VALIDATION_LEVEL_0";
+        case XGL_VALIDATION_LEVEL_1:
+            return "XGL_VALIDATION_LEVEL_1";
+        case XGL_VALIDATION_LEVEL_2:
+            return "XGL_VALIDATION_LEVEL_2";
+        case XGL_VALIDATION_LEVEL_3:
+            return "XGL_VALIDATION_LEVEL_3";
+        case XGL_VALIDATION_LEVEL_4:
+            return "XGL_VALIDATION_LEVEL_4";
         default:
-            return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+            return "Unhandled XGL_VALIDATION_LEVEL";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    {
+        case XGL_DESCRIPTOR_TYPE_IMAGE:
+            return "XGL_DESCRIPTOR_TYPE_IMAGE";
+        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
+        case XGL_DESCRIPTOR_TYPE_SAMPLER:
+            return "XGL_DESCRIPTOR_TYPE_SAMPLER";
+        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+            return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
+        case XGL_DESCRIPTOR_TYPE_TEXTURE:
+            return "XGL_DESCRIPTOR_TYPE_TEXTURE";
+        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    {
+        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+            return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
+        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+            return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
+        case XGL_ATTACHMENT_STORE_OP_STORE:
+            return "XGL_ATTACHMENT_STORE_OP_STORE";
+        default:
+            return "Unhandled XGL_ATTACHMENT_STORE_OP";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    {
+        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+            return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+            return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+            return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+            return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+        case XGL_IMAGE_CREATE_SPARSE_BIT:
+            return "XGL_IMAGE_CREATE_SPARSE_BIT";
+        default:
+            return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+    switch ((XGL_INDEX_TYPE)input_value)
+    {
+        case XGL_INDEX_16:
+            return "XGL_INDEX_16";
+        case XGL_INDEX_32:
+            return "XGL_INDEX_32";
+        case XGL_INDEX_8:
+            return "XGL_INDEX_8";
+        default:
+            return "Unhandled XGL_INDEX_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    {
+        case XGL_BORDER_COLOR_OPAQUE_BLACK:
+            return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+        case XGL_BORDER_COLOR_OPAQUE_WHITE:
+            return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+            return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
+        default:
+            return "Unhandled XGL_BORDER_COLOR_TYPE";
     }
 }
 
@@ -1543,164 +1471,366 @@
 }
 
 
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_TEX_ADDRESS)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-            return "XGL_TEX_FILTER_LINEAR";
-        case XGL_TEX_FILTER_NEAREST:
-            return "XGL_TEX_FILTER_NEAREST";
+        case XGL_TEX_ADDRESS_CLAMP:
+            return "XGL_TEX_ADDRESS_CLAMP";
+        case XGL_TEX_ADDRESS_CLAMP_BORDER:
+            return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+        case XGL_TEX_ADDRESS_MIRROR:
+            return "XGL_TEX_ADDRESS_MIRROR";
+        case XGL_TEX_ADDRESS_MIRROR_ONCE:
+            return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+        case XGL_TEX_ADDRESS_WRAP:
+            return "XGL_TEX_ADDRESS_WRAP";
         default:
-            return "Unhandled XGL_TEX_FILTER";
+            return "Unhandled XGL_TEX_ADDRESS";
     }
 }
 
 
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+    switch ((XGL_DEPTH_MODE)input_value)
     {
-        case XGL_TOPOLOGY_LINE_LIST:
-            return "XGL_TOPOLOGY_LINE_LIST";
-        case XGL_TOPOLOGY_LINE_LIST_ADJ:
-            return "XGL_TOPOLOGY_LINE_LIST_ADJ";
-        case XGL_TOPOLOGY_LINE_STRIP:
-            return "XGL_TOPOLOGY_LINE_STRIP";
-        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
-            return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
-        case XGL_TOPOLOGY_PATCH:
-            return "XGL_TOPOLOGY_PATCH";
-        case XGL_TOPOLOGY_POINT_LIST:
-            return "XGL_TOPOLOGY_POINT_LIST";
-        case XGL_TOPOLOGY_QUAD_LIST:
-            return "XGL_TOPOLOGY_QUAD_LIST";
-        case XGL_TOPOLOGY_QUAD_STRIP:
-            return "XGL_TOPOLOGY_QUAD_STRIP";
-        case XGL_TOPOLOGY_RECT_LIST:
-            return "XGL_TOPOLOGY_RECT_LIST";
-        case XGL_TOPOLOGY_TRIANGLE_LIST:
-            return "XGL_TOPOLOGY_TRIANGLE_LIST";
-        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
-            return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
-        case XGL_TOPOLOGY_TRIANGLE_STRIP:
-            return "XGL_TOPOLOGY_TRIANGLE_STRIP";
-        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
-            return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+            return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+        case XGL_DEPTH_MODE_ZERO_TO_ONE:
+            return "XGL_DEPTH_MODE_ZERO_TO_ONE";
         default:
-            return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+            return "Unhandled XGL_DEPTH_MODE";
     }
 }
 
 
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
 {
-    switch ((XGL_BLEND_FUNC)input_value)
+    switch ((XGL_MEMORY_PRIORITY)input_value)
     {
-        case XGL_BLEND_FUNC_ADD:
-            return "XGL_BLEND_FUNC_ADD";
-        case XGL_BLEND_FUNC_MAX:
-            return "XGL_BLEND_FUNC_MAX";
-        case XGL_BLEND_FUNC_MIN:
-            return "XGL_BLEND_FUNC_MIN";
-        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
-            return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
-        case XGL_BLEND_FUNC_SUBTRACT:
-            return "XGL_BLEND_FUNC_SUBTRACT";
+        case XGL_MEMORY_PRIORITY_HIGH:
+            return "XGL_MEMORY_PRIORITY_HIGH";
+        case XGL_MEMORY_PRIORITY_LOW:
+            return "XGL_MEMORY_PRIORITY_LOW";
+        case XGL_MEMORY_PRIORITY_NORMAL:
+            return "XGL_MEMORY_PRIORITY_NORMAL";
+        case XGL_MEMORY_PRIORITY_UNUSED:
+            return "XGL_MEMORY_PRIORITY_UNUSED";
+        case XGL_MEMORY_PRIORITY_VERY_HIGH:
+            return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+        case XGL_MEMORY_PRIORITY_VERY_LOW:
+            return "XGL_MEMORY_PRIORITY_VERY_LOW";
         default:
-            return "Unhandled XGL_BLEND_FUNC";
+            return "Unhandled XGL_MEMORY_PRIORITY";
     }
 }
 
 
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-            return "XGL_FRONT_FACE_CCW";
-        case XGL_FRONT_FACE_CW:
-            return "XGL_FRONT_FACE_CW";
+        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
         default:
-            return "Unhandled XGL_FACE_ORIENTATION";
+            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_QUEUE_FLAGS)input_value)
     {
-        case XGL_IMAGE_1D:
-            return "XGL_IMAGE_1D";
-        case XGL_IMAGE_2D:
-            return "XGL_IMAGE_2D";
-        case XGL_IMAGE_3D:
-            return "XGL_IMAGE_3D";
+        case XGL_QUEUE_COMPUTE_BIT:
+            return "XGL_QUEUE_COMPUTE_BIT";
+        case XGL_QUEUE_DMA_BIT:
+            return "XGL_QUEUE_DMA_BIT";
+        case XGL_QUEUE_EXTENDED_BIT:
+            return "XGL_QUEUE_EXTENDED_BIT";
+        case XGL_QUEUE_GRAPHICS_BIT:
+            return "XGL_QUEUE_GRAPHICS_BIT";
         default:
-            return "Unhandled XGL_IMAGE_TYPE";
+            return "Unhandled XGL_QUEUE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
     {
-        case XGL_IMAGE_FORMAT_CLASS_128_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
-            return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
-        case XGL_IMAGE_FORMAT_CLASS_16_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_24_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_32_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_48_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_64_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
-            return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
-        case XGL_IMAGE_FORMAT_CLASS_8_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_96_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_D16:
-            return "XGL_IMAGE_FORMAT_CLASS_D16";
-        case XGL_IMAGE_FORMAT_CLASS_D16S8:
-            return "XGL_IMAGE_FORMAT_CLASS_D16S8";
-        case XGL_IMAGE_FORMAT_CLASS_D24:
-            return "XGL_IMAGE_FORMAT_CLASS_D24";
-        case XGL_IMAGE_FORMAT_CLASS_D24S8:
-            return "XGL_IMAGE_FORMAT_CLASS_D24S8";
-        case XGL_IMAGE_FORMAT_CLASS_D32:
-            return "XGL_IMAGE_FORMAT_CLASS_D32";
-        case XGL_IMAGE_FORMAT_CLASS_D32S8:
-            return "XGL_IMAGE_FORMAT_CLASS_D32S8";
-        case XGL_IMAGE_FORMAT_CLASS_LINEAR:
-            return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
-        case XGL_IMAGE_FORMAT_CLASS_S8:
-            return "XGL_IMAGE_FORMAT_CLASS_S8";
+        case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+            return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
+        case XGL_MEMORY_INPUT_COPY_BIT:
+            return "XGL_MEMORY_INPUT_COPY_BIT";
+        case XGL_MEMORY_INPUT_CPU_READ_BIT:
+            return "XGL_MEMORY_INPUT_CPU_READ_BIT";
+        case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+            return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+        case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+            return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
+        case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+            return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
+        case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+            return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
+        case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+            return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
+        case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+            return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
         default:
-            return "Unhandled XGL_IMAGE_FORMAT_CLASS";
+            return "Unhandled XGL_MEMORY_INPUT_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
 {
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
     {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-            return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-            return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
-            return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+            return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+            return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
         default:
-            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+            return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+    }
+}
+
+
+static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+    switch ((XGL_STRUCTURE_TYPE)input_value)
+    {
+        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+            return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
+        case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+            return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+            return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
+        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
+        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+            return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
+        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+            return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+            return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
+        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
+        case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+            return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
+        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+            return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
+        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+            return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
+        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+            return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
+        case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+            return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
+        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+            return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
+        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+            return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
+        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+            return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
+        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
+        default:
+            return "Unhandled XGL_STRUCTURE_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    {
+        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+            return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+        case XGL_MEMORY_OUTPUT_COPY_BIT:
+            return "XGL_MEMORY_OUTPUT_COPY_BIT";
+        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+            return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+            return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+            return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+        default:
+            return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+{
+    switch ((XGL_LOGIC_OP)input_value)
+    {
+        case XGL_LOGIC_OP_AND:
+            return "XGL_LOGIC_OP_AND";
+        case XGL_LOGIC_OP_AND_INVERTED:
+            return "XGL_LOGIC_OP_AND_INVERTED";
+        case XGL_LOGIC_OP_AND_REVERSE:
+            return "XGL_LOGIC_OP_AND_REVERSE";
+        case XGL_LOGIC_OP_CLEAR:
+            return "XGL_LOGIC_OP_CLEAR";
+        case XGL_LOGIC_OP_COPY:
+            return "XGL_LOGIC_OP_COPY";
+        case XGL_LOGIC_OP_COPY_INVERTED:
+            return "XGL_LOGIC_OP_COPY_INVERTED";
+        case XGL_LOGIC_OP_EQUIV:
+            return "XGL_LOGIC_OP_EQUIV";
+        case XGL_LOGIC_OP_INVERT:
+            return "XGL_LOGIC_OP_INVERT";
+        case XGL_LOGIC_OP_NAND:
+            return "XGL_LOGIC_OP_NAND";
+        case XGL_LOGIC_OP_NOOP:
+            return "XGL_LOGIC_OP_NOOP";
+        case XGL_LOGIC_OP_NOR:
+            return "XGL_LOGIC_OP_NOR";
+        case XGL_LOGIC_OP_OR:
+            return "XGL_LOGIC_OP_OR";
+        case XGL_LOGIC_OP_OR_INVERTED:
+            return "XGL_LOGIC_OP_OR_INVERTED";
+        case XGL_LOGIC_OP_OR_REVERSE:
+            return "XGL_LOGIC_OP_OR_REVERSE";
+        case XGL_LOGIC_OP_SET:
+            return "XGL_LOGIC_OP_SET";
+        case XGL_LOGIC_OP_XOR:
+            return "XGL_LOGIC_OP_XOR";
+        default:
+            return "Unhandled XGL_LOGIC_OP";
+    }
+}
+
+
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+        default:
+            return "Unhandled XGL_FORMAT_INFO_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    {
+        case XGL_CHANNEL_SWIZZLE_A:
+            return "XGL_CHANNEL_SWIZZLE_A";
+        case XGL_CHANNEL_SWIZZLE_B:
+            return "XGL_CHANNEL_SWIZZLE_B";
+        case XGL_CHANNEL_SWIZZLE_G:
+            return "XGL_CHANNEL_SWIZZLE_G";
+        case XGL_CHANNEL_SWIZZLE_ONE:
+            return "XGL_CHANNEL_SWIZZLE_ONE";
+        case XGL_CHANNEL_SWIZZLE_R:
+            return "XGL_CHANNEL_SWIZZLE_R";
+        case XGL_CHANNEL_SWIZZLE_ZERO:
+            return "XGL_CHANNEL_SWIZZLE_ZERO";
+        default:
+            return "Unhandled XGL_CHANNEL_SWIZZLE";
+    }
+}
+
+
+static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+{
+    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    {
+        case XGL_PIPELINE_BIND_POINT_COMPUTE:
+            return "XGL_PIPELINE_BIND_POINT_COMPUTE";
+        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+            return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
+        default:
+            return "Unhandled XGL_PIPELINE_BIND_POINT";
     }
 }
 
@@ -1719,164 +1849,34 @@
 }
 
 
-static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
 {
-    switch ((XGL_RESULT)input_value)
+    switch ((XGL_OBJECT_INFO_TYPE)input_value)
     {
-        case XGL_ERROR_BAD_PIPELINE_DATA:
-            return "XGL_ERROR_BAD_PIPELINE_DATA";
-        case XGL_ERROR_BAD_SHADER_CODE:
-            return "XGL_ERROR_BAD_SHADER_CODE";
-        case XGL_ERROR_BUILDING_COMMAND_BUFFER:
-            return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
-        case XGL_ERROR_DEVICE_ALREADY_CREATED:
-            return "XGL_ERROR_DEVICE_ALREADY_CREATED";
-        case XGL_ERROR_DEVICE_LOST:
-            return "XGL_ERROR_DEVICE_LOST";
-        case XGL_ERROR_INCOMPATIBLE_DEVICE:
-            return "XGL_ERROR_INCOMPATIBLE_DEVICE";
-        case XGL_ERROR_INCOMPATIBLE_DRIVER:
-            return "XGL_ERROR_INCOMPATIBLE_DRIVER";
-        case XGL_ERROR_INCOMPATIBLE_QUEUE:
-            return "XGL_ERROR_INCOMPATIBLE_QUEUE";
-        case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
-            return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
-        case XGL_ERROR_INITIALIZATION_FAILED:
-            return "XGL_ERROR_INITIALIZATION_FAILED";
-        case XGL_ERROR_INVALID_ALIGNMENT:
-            return "XGL_ERROR_INVALID_ALIGNMENT";
-        case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
-            return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
-        case XGL_ERROR_INVALID_EXTENSION:
-            return "XGL_ERROR_INVALID_EXTENSION";
-        case XGL_ERROR_INVALID_FLAGS:
-            return "XGL_ERROR_INVALID_FLAGS";
-        case XGL_ERROR_INVALID_FORMAT:
-            return "XGL_ERROR_INVALID_FORMAT";
-        case XGL_ERROR_INVALID_HANDLE:
-            return "XGL_ERROR_INVALID_HANDLE";
-        case XGL_ERROR_INVALID_IMAGE:
-            return "XGL_ERROR_INVALID_IMAGE";
-        case XGL_ERROR_INVALID_MEMORY_SIZE:
-            return "XGL_ERROR_INVALID_MEMORY_SIZE";
-        case XGL_ERROR_INVALID_OBJECT_TYPE:
-            return "XGL_ERROR_INVALID_OBJECT_TYPE";
-        case XGL_ERROR_INVALID_ORDINAL:
-            return "XGL_ERROR_INVALID_ORDINAL";
-        case XGL_ERROR_INVALID_POINTER:
-            return "XGL_ERROR_INVALID_POINTER";
-        case XGL_ERROR_INVALID_QUEUE_TYPE:
-            return "XGL_ERROR_INVALID_QUEUE_TYPE";
-        case XGL_ERROR_INVALID_VALUE:
-            return "XGL_ERROR_INVALID_VALUE";
-        case XGL_ERROR_MEMORY_MAP_FAILED:
-            return "XGL_ERROR_MEMORY_MAP_FAILED";
-        case XGL_ERROR_MEMORY_NOT_BOUND:
-            return "XGL_ERROR_MEMORY_NOT_BOUND";
-        case XGL_ERROR_MEMORY_UNMAP_FAILED:
-            return "XGL_ERROR_MEMORY_UNMAP_FAILED";
-        case XGL_ERROR_NOT_MAPPABLE:
-            return "XGL_ERROR_NOT_MAPPABLE";
-        case XGL_ERROR_NOT_SHAREABLE:
-            return "XGL_ERROR_NOT_SHAREABLE";
-        case XGL_ERROR_OUT_OF_GPU_MEMORY:
-            return "XGL_ERROR_OUT_OF_GPU_MEMORY";
-        case XGL_ERROR_OUT_OF_MEMORY:
-            return "XGL_ERROR_OUT_OF_MEMORY";
-        case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
-            return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
-        case XGL_ERROR_UNAVAILABLE:
-            return "XGL_ERROR_UNAVAILABLE";
-        case XGL_ERROR_UNKNOWN:
-            return "XGL_ERROR_UNKNOWN";
-        case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
-            return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
-        case XGL_EVENT_RESET:
-            return "XGL_EVENT_RESET";
-        case XGL_EVENT_SET:
-            return "XGL_EVENT_SET";
-        case XGL_NOT_READY:
-            return "XGL_NOT_READY";
-        case XGL_SUCCESS:
-            return "XGL_SUCCESS";
-        case XGL_TIMEOUT:
-            return "XGL_TIMEOUT";
-        case XGL_UNSUPPORTED:
-            return "XGL_UNSUPPORTED";
+        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+            return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
         default:
-            return "Unhandled XGL_RESULT";
+            return "Unhandled XGL_OBJECT_INFO_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
     {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+            return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+            return "XGL_DEVICE_CREATE_VALIDATION_BIT";
         default:
-            return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
-    {
-        case XGL_SYSTEM_ALLOC_API_OBJECT:
-            return "XGL_SYSTEM_ALLOC_API_OBJECT";
-        case XGL_SYSTEM_ALLOC_DEBUG:
-            return "XGL_SYSTEM_ALLOC_DEBUG";
-        case XGL_SYSTEM_ALLOC_INTERNAL:
-            return "XGL_SYSTEM_ALLOC_INTERNAL";
-        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
-            return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
-        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
-            return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
-        default:
-            return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
-    switch ((XGL_STENCIL_OP)input_value)
-    {
-        case XGL_STENCIL_OP_DEC_CLAMP:
-            return "XGL_STENCIL_OP_DEC_CLAMP";
-        case XGL_STENCIL_OP_DEC_WRAP:
-            return "XGL_STENCIL_OP_DEC_WRAP";
-        case XGL_STENCIL_OP_INC_CLAMP:
-            return "XGL_STENCIL_OP_INC_CLAMP";
-        case XGL_STENCIL_OP_INC_WRAP:
-            return "XGL_STENCIL_OP_INC_WRAP";
-        case XGL_STENCIL_OP_INVERT:
-            return "XGL_STENCIL_OP_INVERT";
-        case XGL_STENCIL_OP_KEEP:
-            return "XGL_STENCIL_OP_KEEP";
-        case XGL_STENCIL_OP_REPLACE:
-            return "XGL_STENCIL_OP_REPLACE";
-        case XGL_STENCIL_OP_ZERO:
-            return "XGL_STENCIL_OP_ZERO";
-        default:
-            return "Unhandled XGL_STENCIL_OP";
-    }
-}
-
-
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
-    {
-        case XGL_TIMESTAMP_BOTTOM:
-            return "XGL_TIMESTAMP_BOTTOM";
-        case XGL_TIMESTAMP_TOP:
-            return "XGL_TIMESTAMP_TOP";
-        default:
-            return "Unhandled XGL_TIMESTAMP_TYPE";
+            return "Unhandled XGL_DEVICE_CREATE_FLAGS";
     }
 }
 
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h
index d9fa7e4..36d35e6 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h
@@ -3,12 +3,24 @@
 #include <xgl.h>
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
     {
-        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
-        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+    switch ((XGL_IMAGE_TILING)input_value)
+    {
+        case XGL_LINEAR_TILING:
+        case XGL_OPTIMAL_TILING:
             return 1;
         default:
             return 0;
@@ -29,193 +41,28 @@
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
 {
-    switch ((XGL_MEMORY_TYPE)input_value)
+    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
     {
-        case XGL_MEMORY_TYPE_BUFFER:
-        case XGL_MEMORY_TYPE_IMAGE:
-        case XGL_MEMORY_TYPE_OTHER:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
-    {
-        case XGL_SHADER_STAGE_COMPUTE:
-        case XGL_SHADER_STAGE_FRAGMENT:
-        case XGL_SHADER_STAGE_GEOMETRY:
-        case XGL_SHADER_STAGE_TESS_CONTROL:
-        case XGL_SHADER_STAGE_TESS_EVALUATION:
-        case XGL_SHADER_STAGE_VERTEX:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
-    switch ((XGL_CULL_MODE)input_value)
-    {
-        case XGL_CULL_BACK:
-        case XGL_CULL_FRONT:
-        case XGL_CULL_FRONT_AND_BACK:
-        case XGL_CULL_NONE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
-    switch ((XGL_IMAGE_LAYOUT)input_value)
-    {
-        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_GENERAL:
-        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
-    switch ((XGL_MEMORY_PRIORITY)input_value)
-    {
-        case XGL_MEMORY_PRIORITY_HIGH:
-        case XGL_MEMORY_PRIORITY_LOW:
-        case XGL_MEMORY_PRIORITY_NORMAL:
-        case XGL_MEMORY_PRIORITY_UNUSED:
-        case XGL_MEMORY_PRIORITY_VERY_HIGH:
-        case XGL_MEMORY_PRIORITY_VERY_LOW:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
-    switch ((XGL_QUERY_TYPE)input_value)
-    {
-        case XGL_QUERY_OCCLUSION:
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
-    switch ((XGL_VALIDATION_LEVEL)input_value)
-    {
-        case XGL_VALIDATION_LEVEL_0:
-        case XGL_VALIDATION_LEVEL_1:
-        case XGL_VALIDATION_LEVEL_2:
-        case XGL_VALIDATION_LEVEL_3:
-        case XGL_VALIDATION_LEVEL_4:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
-    switch ((XGL_STATE_BIND_POINT)input_value)
-    {
-        case XGL_STATE_BIND_COLOR_BLEND:
-        case XGL_STATE_BIND_DEPTH_STENCIL:
-        case XGL_STATE_BIND_RASTER:
-        case XGL_STATE_BIND_VIEWPORT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
-    {
-        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
-        case XGL_BUFFER_CREATE_SPARSE_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
-    {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
-    {
-        case XGL_BUFFER_VIEW_RAW:
-        case XGL_BUFFER_VIEW_STRUCTURED:
-        case XGL_BUFFER_VIEW_TYPED:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+        case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+        case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+        case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_D16:
+        case XGL_IMAGE_FORMAT_CLASS_D16S8:
+        case XGL_IMAGE_FORMAT_CLASS_D24:
+        case XGL_IMAGE_FORMAT_CLASS_D24S8:
+        case XGL_IMAGE_FORMAT_CLASS_D32:
+        case XGL_IMAGE_FORMAT_CLASS_D32S8:
+        case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+        case XGL_IMAGE_FORMAT_CLASS_S8:
             return 1;
         default:
             return 0;
@@ -244,11 +91,14 @@
 }
 
 
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
 {
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
     {
-        case XGL_QUERY_IMPRECISE_DATA_BIT:
+        case XGL_IMAGE_VIEW_1D:
+        case XGL_IMAGE_VIEW_2D:
+        case XGL_IMAGE_VIEW_3D:
+        case XGL_IMAGE_VIEW_CUBE:
             return 1;
         default:
             return 0;
@@ -256,15 +106,14 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
 {
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
     {
-        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
-        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
-        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
-        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
-        case XGL_IMAGE_CREATE_SPARSE_BIT:
+        case XGL_GPU_TYPE_DISCRETE:
+        case XGL_GPU_TYPE_INTEGRATED:
+        case XGL_GPU_TYPE_OTHER:
+        case XGL_GPU_TYPE_VIRTUAL:
             return 1;
         default:
             return 0;
@@ -272,13 +121,12 @@
 }
 
 
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 {
-    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+    switch ((XGL_QUERY_TYPE)input_value)
     {
-        case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
-        case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
-        case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+        case XGL_QUERY_OCCLUSION:
+        case XGL_QUERY_PIPELINE_STATISTICS:
             return 1;
         default:
             return 0;
@@ -286,17 +134,15 @@
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
 {
-    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
     {
-        case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
-        case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
-        case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
-        case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
-        case XGL_MEMORY_PROPERTY_GPU_ONLY:
-        case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
-        case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+        case XGL_SYSTEM_ALLOC_API_OBJECT:
+        case XGL_SYSTEM_ALLOC_DEBUG:
+        case XGL_SYSTEM_ALLOC_INTERNAL:
+        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
             return 1;
         default:
             return 0;
@@ -323,12 +169,13 @@
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
 {
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
     {
-        case XGL_PIPELINE_BIND_POINT_COMPUTE:
-        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+        case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+        case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+        case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
             return 1;
         default:
             return 0;
@@ -336,14 +183,13 @@
 }
 
 
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
 {
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
     {
-        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+        case XGL_ATTACHMENT_LOAD_OP_LOAD:
             return 1;
         default:
             return 0;
@@ -351,22 +197,13 @@
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 {
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    switch ((XGL_IMAGE_ASPECT)input_value)
     {
-        case XGL_DESCRIPTOR_TYPE_IMAGE:
-        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
-        case XGL_DESCRIPTOR_TYPE_SAMPLER:
-        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
-        case XGL_DESCRIPTOR_TYPE_TEXTURE:
-        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+        case XGL_IMAGE_ASPECT_COLOR:
+        case XGL_IMAGE_ASPECT_DEPTH:
+        case XGL_IMAGE_ASPECT_STENCIL:
             return 1;
         default:
             return 0;
@@ -374,12 +211,12 @@
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
     {
-        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
-        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+        case XGL_BUFFER_CREATE_SPARSE_BIT:
             return 1;
         default:
             return 0;
@@ -387,16 +224,17 @@
 }
 
 
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
     {
-        case XGL_CHANNEL_SWIZZLE_A:
-        case XGL_CHANNEL_SWIZZLE_B:
-        case XGL_CHANNEL_SWIZZLE_G:
-        case XGL_CHANNEL_SWIZZLE_ONE:
-        case XGL_CHANNEL_SWIZZLE_R:
-        case XGL_CHANNEL_SWIZZLE_ZERO:
+        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
             return 1;
         default:
             return 0;
@@ -404,15 +242,152 @@
 }
 
 
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
 {
-    switch ((XGL_TEX_ADDRESS)input_value)
+    switch ((XGL_FACE_ORIENTATION)input_value)
     {
-        case XGL_TEX_ADDRESS_CLAMP:
-        case XGL_TEX_ADDRESS_CLAMP_BORDER:
-        case XGL_TEX_ADDRESS_MIRROR:
-        case XGL_TEX_ADDRESS_MIRROR_ONCE:
-        case XGL_TEX_ADDRESS_WRAP:
+        case XGL_FRONT_FACE_CCW:
+        case XGL_FRONT_FACE_CW:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+    switch ((XGL_TEX_FILTER)input_value)
+    {
+        case XGL_TEX_FILTER_LINEAR:
+        case XGL_TEX_FILTER_NEAREST:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    {
+        case XGL_BUFFER_VIEW_RAW:
+        case XGL_BUFFER_VIEW_STRUCTURED:
+        case XGL_BUFFER_VIEW_TYPED:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    {
+        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+    switch ((XGL_QUEUE_TYPE)input_value)
+    {
+        case XGL_QUEUE_TYPE_COMPUTE:
+        case XGL_QUEUE_TYPE_DMA:
+        case XGL_QUEUE_TYPE_GRAPHICS:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    {
+        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+    switch ((XGL_COORDINATE_ORIGIN)input_value)
+    {
+        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+    switch ((XGL_FILL_MODE)input_value)
+    {
+        case XGL_FILL_POINTS:
+        case XGL_FILL_SOLID:
+        case XGL_FILL_WIREFRAME:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+    switch ((XGL_WAIT_EVENT)input_value)
+    {
+        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+        case XGL_WAIT_EVENT_TOP_OF_PIPE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+    switch ((XGL_STENCIL_OP)input_value)
+    {
+        case XGL_STENCIL_OP_DEC_CLAMP:
+        case XGL_STENCIL_OP_DEC_WRAP:
+        case XGL_STENCIL_OP_INC_CLAMP:
+        case XGL_STENCIL_OP_INC_WRAP:
+        case XGL_STENCIL_OP_INVERT:
+        case XGL_STENCIL_OP_KEEP:
+        case XGL_STENCIL_OP_REPLACE:
+        case XGL_STENCIL_OP_ZERO:
             return 1;
         default:
             return 0;
@@ -445,12 +420,15 @@
 }
 
 
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 {
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    switch ((XGL_BLEND_FUNC)input_value)
     {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+        case XGL_BLEND_FUNC_ADD:
+        case XGL_BLEND_FUNC_MAX:
+        case XGL_BLEND_FUNC_MIN:
+        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+        case XGL_BLEND_FUNC_SUBTRACT:
             return 1;
         default:
             return 0;
@@ -458,319 +436,20 @@
 }
 
 
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
 {
-    switch ((XGL_QUEUE_FLAGS)input_value)
+    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
     {
-        case XGL_QUEUE_COMPUTE_BIT:
-        case XGL_QUEUE_DMA_BIT:
-        case XGL_QUEUE_EXTENDED_BIT:
-        case XGL_QUEUE_GRAPHICS_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
-    {
-        case XGL_IMAGE_VIEW_1D:
-        case XGL_IMAGE_VIEW_2D:
-        case XGL_IMAGE_VIEW_3D:
-        case XGL_IMAGE_VIEW_CUBE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
-    {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
-    {
-        case XGL_MEMORY_REF_READ_ONLY_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
-    switch ((XGL_STRUCTURE_TYPE)input_value)
-    {
-        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
-        case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
-        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
-        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
-        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
-        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
-        case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
-        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
-        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
-        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
-        case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
-{
-    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
-    {
-        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
-        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
-        case XGL_ATTACHMENT_STORE_OP_STORE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
-    switch ((XGL_WAIT_EVENT)input_value)
-    {
-        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
-        case XGL_WAIT_EVENT_TOP_OF_PIPE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
-    switch ((XGL_DEPTH_MODE)input_value)
-    {
-        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
-        case XGL_DEPTH_MODE_ZERO_TO_ONE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
-    switch ((XGL_FILL_MODE)input_value)
-    {
-        case XGL_FILL_POINTS:
-        case XGL_FILL_SOLID:
-        case XGL_FILL_WIREFRAME:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
-    {
-        case XGL_TEX_MIPMAP_BASE:
-        case XGL_TEX_MIPMAP_LINEAR:
-        case XGL_TEX_MIPMAP_NEAREST:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
-    switch ((XGL_SET_EVENT)input_value)
-    {
-        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
-        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
-        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
-        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
-        case XGL_SET_EVENT_TOP_OF_PIPE:
-        case XGL_SET_EVENT_TRANSFER_COMPLETE:
-        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
-    switch ((XGL_COORDINATE_ORIGIN)input_value)
-    {
-        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
-        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
-    switch ((XGL_IMAGE_ASPECT)input_value)
-    {
-        case XGL_IMAGE_ASPECT_COLOR:
-        case XGL_IMAGE_ASPECT_DEPTH:
-        case XGL_IMAGE_ASPECT_STENCIL:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
-        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
-        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
-        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
-    {
-        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
-        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
-    switch ((XGL_INDEX_TYPE)input_value)
-    {
-        case XGL_INDEX_16:
-        case XGL_INDEX_32:
-        case XGL_INDEX_8:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
-{
-    switch ((XGL_IMAGE_TILING)input_value)
-    {
-        case XGL_LINEAR_TILING:
-        case XGL_OPTIMAL_TILING:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
-{
-    switch ((XGL_QUEUE_TYPE)input_value)
-    {
-        case XGL_QUEUE_TYPE_COMPUTE:
-        case XGL_QUEUE_TYPE_DMA:
-        case XGL_QUEUE_TYPE_GRAPHICS:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
-{
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
-    {
-        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
-        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
-        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
-        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
-        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
-        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
-        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+        case XGL_IMAGE_USAGE_GENERAL:
+        case XGL_IMAGE_USAGE_IMAGE_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+        case XGL_IMAGE_USAGE_TEXTURE_BIT:
+        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
             return 1;
         default:
             return 0;
@@ -796,19 +475,13 @@
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
 {
-    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+    switch ((XGL_TEX_MIPMAP_MODE)input_value)
     {
-        case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
-        case XGL_MEMORY_INPUT_COPY_BIT:
-        case XGL_MEMORY_INPUT_CPU_READ_BIT:
-        case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-        case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
-        case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
-        case XGL_MEMORY_INPUT_SHADER_READ_BIT:
-        case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
-        case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+        case XGL_TEX_MIPMAP_BASE:
+        case XGL_TEX_MIPMAP_LINEAR:
+        case XGL_TEX_MIPMAP_NEAREST:
             return 1;
         default:
             return 0;
@@ -816,11 +489,50 @@
 }
 
 
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
 {
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    switch ((XGL_RESULT)input_value)
     {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+        case XGL_ERROR_BAD_PIPELINE_DATA:
+        case XGL_ERROR_BAD_SHADER_CODE:
+        case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+        case XGL_ERROR_DEVICE_ALREADY_CREATED:
+        case XGL_ERROR_DEVICE_LOST:
+        case XGL_ERROR_INCOMPATIBLE_DEVICE:
+        case XGL_ERROR_INCOMPATIBLE_DRIVER:
+        case XGL_ERROR_INCOMPATIBLE_QUEUE:
+        case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+        case XGL_ERROR_INITIALIZATION_FAILED:
+        case XGL_ERROR_INVALID_ALIGNMENT:
+        case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+        case XGL_ERROR_INVALID_EXTENSION:
+        case XGL_ERROR_INVALID_FLAGS:
+        case XGL_ERROR_INVALID_FORMAT:
+        case XGL_ERROR_INVALID_HANDLE:
+        case XGL_ERROR_INVALID_IMAGE:
+        case XGL_ERROR_INVALID_MEMORY_SIZE:
+        case XGL_ERROR_INVALID_OBJECT_TYPE:
+        case XGL_ERROR_INVALID_ORDINAL:
+        case XGL_ERROR_INVALID_POINTER:
+        case XGL_ERROR_INVALID_QUEUE_TYPE:
+        case XGL_ERROR_INVALID_VALUE:
+        case XGL_ERROR_MEMORY_MAP_FAILED:
+        case XGL_ERROR_MEMORY_NOT_BOUND:
+        case XGL_ERROR_MEMORY_UNMAP_FAILED:
+        case XGL_ERROR_NOT_MAPPABLE:
+        case XGL_ERROR_NOT_SHAREABLE:
+        case XGL_ERROR_OUT_OF_GPU_MEMORY:
+        case XGL_ERROR_OUT_OF_MEMORY:
+        case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+        case XGL_ERROR_UNAVAILABLE:
+        case XGL_ERROR_UNKNOWN:
+        case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+        case XGL_EVENT_RESET:
+        case XGL_EVENT_SET:
+        case XGL_NOT_READY:
+        case XGL_SUCCESS:
+        case XGL_TIMEOUT:
+        case XGL_UNSUPPORTED:
             return 1;
         default:
             return 0;
@@ -828,26 +540,17 @@
 }
 
 
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
 {
-    switch ((XGL_LOGIC_OP)input_value)
+    switch ((XGL_SET_EVENT)input_value)
     {
-        case XGL_LOGIC_OP_AND:
-        case XGL_LOGIC_OP_AND_INVERTED:
-        case XGL_LOGIC_OP_AND_REVERSE:
-        case XGL_LOGIC_OP_CLEAR:
-        case XGL_LOGIC_OP_COPY:
-        case XGL_LOGIC_OP_COPY_INVERTED:
-        case XGL_LOGIC_OP_EQUIV:
-        case XGL_LOGIC_OP_INVERT:
-        case XGL_LOGIC_OP_NAND:
-        case XGL_LOGIC_OP_NOOP:
-        case XGL_LOGIC_OP_NOR:
-        case XGL_LOGIC_OP_OR:
-        case XGL_LOGIC_OP_OR_INVERTED:
-        case XGL_LOGIC_OP_OR_REVERSE:
-        case XGL_LOGIC_OP_SET:
-        case XGL_LOGIC_OP_XOR:
+        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+        case XGL_SET_EVENT_TOP_OF_PIPE:
+        case XGL_SET_EVENT_TRANSFER_COMPLETE:
+        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
             return 1;
         default:
             return 0;
@@ -855,15 +558,173 @@
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_STATE_BIND_POINT)input_value)
     {
-        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
-        case XGL_MEMORY_OUTPUT_COPY_BIT:
-        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
-        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+        case XGL_STATE_BIND_COLOR_BLEND:
+        case XGL_STATE_BIND_DEPTH_STENCIL:
+        case XGL_STATE_BIND_RASTER:
+        case XGL_STATE_BIND_VIEWPORT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+    switch ((XGL_IMAGE_LAYOUT)input_value)
+    {
+        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_GENERAL:
+        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    {
+        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+    switch ((XGL_MEMORY_TYPE)input_value)
+    {
+        case XGL_MEMORY_TYPE_BUFFER:
+        case XGL_MEMORY_TYPE_IMAGE:
+        case XGL_MEMORY_TYPE_OTHER:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+    switch ((XGL_CULL_MODE)input_value)
+    {
+        case XGL_CULL_BACK:
+        case XGL_CULL_FRONT:
+        case XGL_CULL_FRONT_AND_BACK:
+        case XGL_CULL_NONE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_REF_FLAGS)input_value)
+    {
+        case XGL_MEMORY_REF_READ_ONLY_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    {
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+    {
+        case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+        case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+        case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+        case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+        case XGL_MEMORY_PROPERTY_GPU_ONLY:
+        case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+        case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+{
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
+    {
+        case XGL_TIMESTAMP_BOTTOM:
+        case XGL_TIMESTAMP_TOP:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+    switch ((XGL_IMAGE_TYPE)input_value)
+    {
+        case XGL_IMAGE_1D:
+        case XGL_IMAGE_2D:
+        case XGL_IMAGE_3D:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    {
+        case XGL_SHADER_STAGE_COMPUTE:
+        case XGL_SHADER_STAGE_FRAGMENT:
+        case XGL_SHADER_STAGE_GEOMETRY:
+        case XGL_SHADER_STAGE_TESS_CONTROL:
+        case XGL_SHADER_STAGE_TESS_EVALUATION:
+        case XGL_SHADER_STAGE_VERTEX:
             return 1;
         default:
             return 0;
@@ -901,14 +762,23 @@
 }
 
 
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
     {
-        case XGL_GPU_TYPE_DISCRETE:
-        case XGL_GPU_TYPE_INTEGRATED:
-        case XGL_GPU_TYPE_OTHER:
-        case XGL_GPU_TYPE_VIRTUAL:
+        case XGL_TOPOLOGY_LINE_LIST:
+        case XGL_TOPOLOGY_LINE_LIST_ADJ:
+        case XGL_TOPOLOGY_LINE_STRIP:
+        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+        case XGL_TOPOLOGY_PATCH:
+        case XGL_TOPOLOGY_POINT_LIST:
+        case XGL_TOPOLOGY_QUAD_LIST:
+        case XGL_TOPOLOGY_QUAD_STRIP:
+        case XGL_TOPOLOGY_RECT_LIST:
+        case XGL_TOPOLOGY_TRIANGLE_LIST:
+        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+        case XGL_TOPOLOGY_TRIANGLE_STRIP:
+        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
             return 1;
         default:
             return 0;
@@ -916,20 +786,96 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
 {
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+    switch ((XGL_VALIDATION_LEVEL)input_value)
     {
-        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
-        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
-        case XGL_IMAGE_USAGE_GENERAL:
-        case XGL_IMAGE_USAGE_IMAGE_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
-        case XGL_IMAGE_USAGE_TEXTURE_BIT:
-        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
-        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+        case XGL_VALIDATION_LEVEL_0:
+        case XGL_VALIDATION_LEVEL_1:
+        case XGL_VALIDATION_LEVEL_2:
+        case XGL_VALIDATION_LEVEL_3:
+        case XGL_VALIDATION_LEVEL_4:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    {
+        case XGL_DESCRIPTOR_TYPE_IMAGE:
+        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+        case XGL_DESCRIPTOR_TYPE_SAMPLER:
+        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+        case XGL_DESCRIPTOR_TYPE_TEXTURE:
+        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    {
+        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+        case XGL_ATTACHMENT_STORE_OP_STORE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    {
+        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+        case XGL_IMAGE_CREATE_SPARSE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+    switch ((XGL_INDEX_TYPE)input_value)
+    {
+        case XGL_INDEX_16:
+        case XGL_INDEX_32:
+        case XGL_INDEX_8:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    {
+        case XGL_BORDER_COLOR_OPAQUE_BLACK:
+        case XGL_BORDER_COLOR_OPAQUE_WHITE:
+        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
             return 1;
         default:
             return 0;
@@ -1115,12 +1061,15 @@
 }
 
 
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_TEX_ADDRESS)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-        case XGL_TEX_FILTER_NEAREST:
+        case XGL_TEX_ADDRESS_CLAMP:
+        case XGL_TEX_ADDRESS_CLAMP_BORDER:
+        case XGL_TEX_ADDRESS_MIRROR:
+        case XGL_TEX_ADDRESS_MIRROR_ONCE:
+        case XGL_TEX_ADDRESS_WRAP:
             return 1;
         default:
             return 0;
@@ -1128,23 +1077,12 @@
 }
 
 
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+    switch ((XGL_DEPTH_MODE)input_value)
     {
-        case XGL_TOPOLOGY_LINE_LIST:
-        case XGL_TOPOLOGY_LINE_LIST_ADJ:
-        case XGL_TOPOLOGY_LINE_STRIP:
-        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
-        case XGL_TOPOLOGY_PATCH:
-        case XGL_TOPOLOGY_POINT_LIST:
-        case XGL_TOPOLOGY_QUAD_LIST:
-        case XGL_TOPOLOGY_QUAD_STRIP:
-        case XGL_TOPOLOGY_RECT_LIST:
-        case XGL_TOPOLOGY_TRIANGLE_LIST:
-        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
-        case XGL_TOPOLOGY_TRIANGLE_STRIP:
-        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+        case XGL_DEPTH_MODE_ZERO_TO_ONE:
             return 1;
         default:
             return 0;
@@ -1152,15 +1090,16 @@
 }
 
 
-static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
 {
-    switch ((XGL_BLEND_FUNC)input_value)
+    switch ((XGL_MEMORY_PRIORITY)input_value)
     {
-        case XGL_BLEND_FUNC_ADD:
-        case XGL_BLEND_FUNC_MAX:
-        case XGL_BLEND_FUNC_MIN:
-        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
-        case XGL_BLEND_FUNC_SUBTRACT:
+        case XGL_MEMORY_PRIORITY_HIGH:
+        case XGL_MEMORY_PRIORITY_LOW:
+        case XGL_MEMORY_PRIORITY_NORMAL:
+        case XGL_MEMORY_PRIORITY_UNUSED:
+        case XGL_MEMORY_PRIORITY_VERY_HIGH:
+        case XGL_MEMORY_PRIORITY_VERY_LOW:
             return 1;
         default:
             return 0;
@@ -1168,12 +1107,14 @@
 }
 
 
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-        case XGL_FRONT_FACE_CW:
+        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
             return 1;
         default:
             return 0;
@@ -1181,13 +1122,14 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_QUEUE_FLAGS)input_value)
     {
-        case XGL_IMAGE_1D:
-        case XGL_IMAGE_2D:
-        case XGL_IMAGE_3D:
+        case XGL_QUEUE_COMPUTE_BIT:
+        case XGL_QUEUE_DMA_BIT:
+        case XGL_QUEUE_EXTENDED_BIT:
+        case XGL_QUEUE_GRAPHICS_BIT:
             return 1;
         default:
             return 0;
@@ -1195,28 +1137,19 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
     {
-        case XGL_IMAGE_FORMAT_CLASS_128_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
-        case XGL_IMAGE_FORMAT_CLASS_16_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_24_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_32_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_48_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_64_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
-        case XGL_IMAGE_FORMAT_CLASS_8_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_96_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_D16:
-        case XGL_IMAGE_FORMAT_CLASS_D16S8:
-        case XGL_IMAGE_FORMAT_CLASS_D24:
-        case XGL_IMAGE_FORMAT_CLASS_D24S8:
-        case XGL_IMAGE_FORMAT_CLASS_D32:
-        case XGL_IMAGE_FORMAT_CLASS_D32S8:
-        case XGL_IMAGE_FORMAT_CLASS_LINEAR:
-        case XGL_IMAGE_FORMAT_CLASS_S8:
+        case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+        case XGL_MEMORY_INPUT_COPY_BIT:
+        case XGL_MEMORY_INPUT_CPU_READ_BIT:
+        case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+        case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+        case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+        case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+        case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+        case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
             return 1;
         default:
             return 0;
@@ -1224,13 +1157,163 @@
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
 {
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
     {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+    switch ((XGL_STRUCTURE_TYPE)input_value)
+    {
+        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+        case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+        case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+        case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    {
+        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+        case XGL_MEMORY_OUTPUT_COPY_BIT:
+        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+{
+    switch ((XGL_LOGIC_OP)input_value)
+    {
+        case XGL_LOGIC_OP_AND:
+        case XGL_LOGIC_OP_AND_INVERTED:
+        case XGL_LOGIC_OP_AND_REVERSE:
+        case XGL_LOGIC_OP_CLEAR:
+        case XGL_LOGIC_OP_COPY:
+        case XGL_LOGIC_OP_COPY_INVERTED:
+        case XGL_LOGIC_OP_EQUIV:
+        case XGL_LOGIC_OP_INVERT:
+        case XGL_LOGIC_OP_NAND:
+        case XGL_LOGIC_OP_NOOP:
+        case XGL_LOGIC_OP_NOR:
+        case XGL_LOGIC_OP_OR:
+        case XGL_LOGIC_OP_OR_INVERTED:
+        case XGL_LOGIC_OP_OR_REVERSE:
+        case XGL_LOGIC_OP_SET:
+        case XGL_LOGIC_OP_XOR:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    {
+        case XGL_CHANNEL_SWIZZLE_A:
+        case XGL_CHANNEL_SWIZZLE_B:
+        case XGL_CHANNEL_SWIZZLE_G:
+        case XGL_CHANNEL_SWIZZLE_ONE:
+        case XGL_CHANNEL_SWIZZLE_R:
+        case XGL_CHANNEL_SWIZZLE_ZERO:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+{
+    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    {
+        case XGL_PIPELINE_BIND_POINT_COMPUTE:
+        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -1251,50 +1334,14 @@
 }
 
 
-static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
 {
-    switch ((XGL_RESULT)input_value)
+    switch ((XGL_OBJECT_INFO_TYPE)input_value)
     {
-        case XGL_ERROR_BAD_PIPELINE_DATA:
-        case XGL_ERROR_BAD_SHADER_CODE:
-        case XGL_ERROR_BUILDING_COMMAND_BUFFER:
-        case XGL_ERROR_DEVICE_ALREADY_CREATED:
-        case XGL_ERROR_DEVICE_LOST:
-        case XGL_ERROR_INCOMPATIBLE_DEVICE:
-        case XGL_ERROR_INCOMPATIBLE_DRIVER:
-        case XGL_ERROR_INCOMPATIBLE_QUEUE:
-        case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
-        case XGL_ERROR_INITIALIZATION_FAILED:
-        case XGL_ERROR_INVALID_ALIGNMENT:
-        case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
-        case XGL_ERROR_INVALID_EXTENSION:
-        case XGL_ERROR_INVALID_FLAGS:
-        case XGL_ERROR_INVALID_FORMAT:
-        case XGL_ERROR_INVALID_HANDLE:
-        case XGL_ERROR_INVALID_IMAGE:
-        case XGL_ERROR_INVALID_MEMORY_SIZE:
-        case XGL_ERROR_INVALID_OBJECT_TYPE:
-        case XGL_ERROR_INVALID_ORDINAL:
-        case XGL_ERROR_INVALID_POINTER:
-        case XGL_ERROR_INVALID_QUEUE_TYPE:
-        case XGL_ERROR_INVALID_VALUE:
-        case XGL_ERROR_MEMORY_MAP_FAILED:
-        case XGL_ERROR_MEMORY_NOT_BOUND:
-        case XGL_ERROR_MEMORY_UNMAP_FAILED:
-        case XGL_ERROR_NOT_MAPPABLE:
-        case XGL_ERROR_NOT_SHAREABLE:
-        case XGL_ERROR_OUT_OF_GPU_MEMORY:
-        case XGL_ERROR_OUT_OF_MEMORY:
-        case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
-        case XGL_ERROR_UNAVAILABLE:
-        case XGL_ERROR_UNKNOWN:
-        case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
-        case XGL_EVENT_RESET:
-        case XGL_EVENT_SET:
-        case XGL_NOT_READY:
-        case XGL_SUCCESS:
-        case XGL_TIMEOUT:
-        case XGL_UNSUPPORTED:
+        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
             return 1;
         default:
             return 0;
@@ -1302,59 +1349,12 @@
 }
 
 
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
     {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
-    {
-        case XGL_SYSTEM_ALLOC_API_OBJECT:
-        case XGL_SYSTEM_ALLOC_DEBUG:
-        case XGL_SYSTEM_ALLOC_INTERNAL:
-        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
-        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
-    switch ((XGL_STENCIL_OP)input_value)
-    {
-        case XGL_STENCIL_OP_DEC_CLAMP:
-        case XGL_STENCIL_OP_DEC_WRAP:
-        case XGL_STENCIL_OP_INC_CLAMP:
-        case XGL_STENCIL_OP_INC_WRAP:
-        case XGL_STENCIL_OP_INVERT:
-        case XGL_STENCIL_OP_KEEP:
-        case XGL_STENCIL_OP_REPLACE:
-        case XGL_STENCIL_OP_ZERO:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
-    {
-        case XGL_TIMESTAMP_BOTTOM:
-        case XGL_TIMESTAMP_TOP:
+        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+        case XGL_DEVICE_CREATE_VALIDATION_BIT:
             return 1;
         default:
             return 0;
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp
index ac5f673..c3e12a2 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp
@@ -23,7 +23,7 @@
  *************************************************************************/
 extern "C" {
 #include "glv_trace_packet_utils.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_packet_id.h"
 }
 
 #include "glvdebug_xgl_settings.h"
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h
index 69f6896..1c448f4 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h
@@ -25,7 +25,7 @@
 #ifndef GLVDEBUG_XGL_QGROUPFRAMESPROXYMODEL_H
 #define GLVDEBUG_XGL_QGROUPFRAMESPROXYMODEL_H
 
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_packet_id.h"
 
 #include "glvdebug_QTraceFileModel.h"
 #include <QAbstractProxyModel>
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
index c7a1caf..cf5e85a 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
@@ -9,17 +9,17 @@
 
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen)
 
-add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h
+add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvreplay_xgl_replay.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvreplay_xgl_replay.cpp
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-replay-h > glvreplay_xgl_replay.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-replay-c > glvreplay_xgl_replay.cpp
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen
@@ -52,10 +52,10 @@
 )
 
 set (HDR_LIST
-    codegen/glvtrace_xgl_packet_id.h
-    codegen/glvtrace_xgl_xgl_structs.h
-    codegen/glvtrace_xgl_xglwsix11ext_structs.h
-    codegen/glvtrace_xgl_xgldbg_structs.h
+    codegen/glv_vk_packet_id.h
+    codegen/glv_vk_vk_structs.h
+    codegen/glv_vk_vkwsix11ext_structs.h
+    codegen/glv_vk_vkdbg_structs.h
     codegen/xgl_enum_string_helper.h
     glvreplay_xgl.h
     glvreplay_xgl_settings.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h
similarity index 99%
copy from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
copy to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h
index d1dded3..d774f98 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h
@@ -29,9 +29,9 @@
 #include "glv_trace_packet_utils.h"
 #include "glv_trace_packet_identifiers.h"
 #include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_vkwsix11ext_structs.h"
 #include "xgl_enum_string_helper.h"
 #if defined(WIN32)
 #define snprintf _snprintf
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vk_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgl_structs.h
rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vk_structs.h
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkdbg_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgldbg_structs.h
rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkdbg_structs.h
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkwsix11ext_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h
rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkwsix11ext_structs.h
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp
index a4ea29a..99c71bb 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp
@@ -36,10 +36,10 @@
 #include <queue>
 glvreplay_settings *g_pReplaySettings;
 extern "C" {
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_vkwsix11ext_structs.h"
+#include "glv_vk_packet_id.h"
 #include "xgl_enum_string_helper.h"
 }
 
@@ -295,6 +295,28 @@
 void xglDisplay::process_event()
 {
 }
+
+void objMemory::setCount(const uint32_t num)
+{
+    m_numAllocations = num;
+}
+
+void objMemory::setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num)
+{
+    if (m_numAllocations != num && m_numAllocations != 0)
+        glv_LogError("objMemory::setReqs, internal mismatch on number of allocations");
+    if (m_pMemReqs == NULL && pReqs != NULL)
+    {
+        m_pMemReqs = (XGL_MEMORY_REQUIREMENTS *) glv_malloc(num * sizeof(XGL_MEMORY_REQUIREMENTS));
+        if (m_pMemReqs == NULL)
+        {
+            glv_LogError("objMemory::setReqs out of memory");
+            return;
+        }
+        memcpy(m_pMemReqs, pReqs, num);
+    }
+}
+
 xglReplay::xglReplay(glvreplay_settings *pReplaySettings)
 {
     g_pReplaySettings = pReplaySettings;
@@ -302,6 +324,7 @@
     m_pDSDump = NULL;
     m_pCBDump = NULL;
     m_pGlvSnapshotPrint = NULL;
+    m_adjustForGPU = false;
     if (g_pReplaySettings && g_pReplaySettings->screenshotList) {
         process_screenshot_list(g_pReplaySettings->screenshotList);
     }
@@ -856,12 +879,12 @@
         case GLV_TPI_XGL_xglAllocMemory:
         {
             struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)(packet->pBody);
-            XGL_GPU_MEMORY local_pMem;
-            replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &local_pMem);
+            struct gpuMemObj local_mem;
+            replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem);
             if (replayResult == XGL_SUCCESS)
             {
-                add_to_map(pPacket->pMem, &local_pMem);
-                add_entry_to_mapData(local_pMem, pPacket->pAllocInfo->allocationSize);
+                add_to_map(pPacket->pMem, &local_mem);
+                add_entry_to_mapData(local_mem.replayGpuMem, pPacket->pAllocInfo->allocationSize);
             }
             CHECK_RETURN_VALUE(xglAllocMemory);
             break;
@@ -869,11 +892,11 @@
         case GLV_TPI_XGL_xglFreeMemory:
         {
             struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)(packet->pBody);
-            XGL_GPU_MEMORY handle = remap(pPacket->mem);
-            replayResult = m_xglFuncs.real_xglFreeMemory(handle);
+            XGL_GPU_MEMORY local_mem = remap(pPacket->mem);
+            replayResult = m_xglFuncs.real_xglFreeMemory(local_mem);
             if (replayResult == XGL_SUCCESS) 
             {
-                rm_entry_from_mapData(handle);
+                rm_entry_from_mapData(local_mem);
                 rm_from_map(pPacket->mem);
             }
             CHECK_RETURN_VALUE(xglFreeMemory);
@@ -889,32 +912,30 @@
         case GLV_TPI_XGL_xglMapMemory:
         {
             struct_xglMapMemory* pPacket = (struct_xglMapMemory*)(packet->pBody);
-            XGL_GPU_MEMORY handle = remap(pPacket->mem);
+            XGL_GPU_MEMORY local_mem = remap(pPacket->mem);
             void* pData;
-            replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);
+            replayResult = m_xglFuncs.real_xglMapMemory(local_mem, pPacket->flags, &pData);
             if (replayResult == XGL_SUCCESS)
-                add_mapping_to_mapData(handle, pData);
+                add_mapping_to_mapData(local_mem, pData);
             CHECK_RETURN_VALUE(xglMapMemory);
             break;
         }
         case GLV_TPI_XGL_xglUnmapMemory:
         {
             struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)(packet->pBody);
-            XGL_GPU_MEMORY handle = remap(pPacket->mem);
-            rm_mapping_from_mapData(handle, pPacket->pData);  // copies data from packet into memory buffer
-            replayResult = m_xglFuncs.real_xglUnmapMemory(handle);
+            XGL_GPU_MEMORY local_mem = remap(pPacket->mem);
+            rm_mapping_from_mapData(local_mem, pPacket->pData);  // copies data from packet into memory buffer
+            replayResult = m_xglFuncs.real_xglUnmapMemory(local_mem);
             CHECK_RETURN_VALUE(xglUnmapMemory);
             break;
         }
         case GLV_TPI_XGL_xglPinSystemMemory:
         {
             struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)(packet->pBody);
-            XGL_GPU_MEMORY local_pMem;
-            replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_pMem);
+            struct gpuMemObj local_mem;
+            replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem);
             if (replayResult == XGL_SUCCESS)
-            {
-                add_to_map(pPacket->pMem, &local_pMem);
-            }
+                add_to_map(pPacket->pMem, &local_mem);
             CHECK_RETURN_VALUE(xglPinSystemMemory);
             break;
         }
@@ -992,16 +1013,55 @@
                 pData = glv_malloc(*pPacket->pDataSize);
                 memcpy(pData, pPacket->pData, *pPacket->pDataSize);
             }
+            // TODO only search for object once rather than at remap() and init_objMemXXX()
             replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);
             if (replayResult == XGL_SUCCESS)
             {
                 if (size != *pPacket->pDataSize && pData != NULL)
                 {
                     glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
-                }
-                else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+                } else if (pData != NULL)
                 {
-                    glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\n");
+                    switch (pPacket->infoType)
+                    {
+                        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+                        {
+                            uint32_t traceCount = *((uint32_t *) pPacket->pData);
+                            uint32_t replayCount = *((uint32_t *) pData);
+                            if (traceCount != replayCount)
+                                glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_ALLOCATION_COUNT) mismatch: trace count %u, replay count %u\n", traceCount, replayCount);
+                            if (m_adjustForGPU)
+                                init_objMemCount(pPacket->object, replayCount);
+                            break;
+                        }
+                        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+                        {
+                            XGL_MEMORY_REQUIREMENTS *traceReqs = (XGL_MEMORY_REQUIREMENTS *) pPacket->pData;
+                            XGL_MEMORY_REQUIREMENTS *replayReqs = (XGL_MEMORY_REQUIREMENTS *) pData;
+                            unsigned int num = size / sizeof(XGL_MEMORY_REQUIREMENTS);
+                            for (unsigned int i = 0; i < num; i++)
+                            {
+                                if (traceReqs->size != replayReqs->size)
+                                    glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace size %u, replay size %u\n", traceReqs->size, replayReqs->size);
+                                if (traceReqs->alignment != replayReqs->alignment)
+                                    glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace alignment %u, replay aligmnent %u\n", traceReqs->alignment, replayReqs->alignment);
+                                if (traceReqs->granularity != replayReqs->granularity)
+                                    glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace granularity %u, replay granularity %u\n", traceReqs->granularity, replayReqs->granularity);
+                                if (traceReqs->memProps != replayReqs->memProps)
+                                    glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memProps %u, replay memProps %u\n", traceReqs->memProps, replayReqs->memProps);
+                                if (traceReqs->memType != replayReqs->memType)
+                                    glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memType %u, replay memType %u\n", traceReqs->memType, replayReqs->memType);
+                                traceReqs++;
+                                replayReqs++;
+                            }
+                            if (m_adjustForGPU)
+                                init_objMemReqs(pPacket->object, replayReqs - num, num);
+                            break;
+                        }
+                        default:
+                            if (memcmp(pData, pPacket->pData, size) != 0)
+                                glv_LogWarn("xglGetObjectInfo() mismatch on *pData: between trace and replay *pDataSize %u\n", size);
+                    }
                 }
             }
             glv_free(pData);
@@ -1174,11 +1234,11 @@
         case GLV_TPI_XGL_xglCreateBuffer:
         {
             struct_xglCreateBuffer* pPacket = (struct_xglCreateBuffer*)(packet->pBody);
-            XGL_BUFFER local_pBuffer;
-            replayResult = m_xglFuncs.real_xglCreateBuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_pBuffer);
+            struct bufferObj local_bufferObj;
+            replayResult = m_xglFuncs.real_xglCreateBuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer);
             if (replayResult == XGL_SUCCESS)
             {
-                add_to_map(pPacket->pBuffer, &local_pBuffer);
+                add_to_map(pPacket->pBuffer, &local_bufferObj);
             }
             CHECK_RETURN_VALUE(xglCreateBuffer);
             break;
@@ -1201,11 +1261,11 @@
         case GLV_TPI_XGL_xglCreateImage:
         {
             struct_xglCreateImage* pPacket = (struct_xglCreateImage*)(packet->pBody);
-            XGL_IMAGE local_pImage;
-            replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &local_pImage);
+            struct imageObj local_imageObj;
+            replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage);
             if (replayResult == XGL_SUCCESS)
             {
-                add_to_map(pPacket->pImage, &local_pImage);
+                add_to_map(pPacket->pImage, &local_imageObj);
             }
             CHECK_RETURN_VALUE(xglCreateImage);
             break;
@@ -2164,19 +2224,19 @@
         {
             struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)(packet->pBody);
 #if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
-            XGL_IMAGE img;
-            XGL_GPU_MEMORY mem;
+            struct imageObj local_imgObj;
+            struct gpuMemObj local_mem;
             m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);
             m_display->imageWidth.push_back(pPacket->pCreateInfo->extent.width);
-            replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);
+            replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imgObj.replayImage, &local_mem.replayGpuMem);
             if (replayResult == XGL_SUCCESS)
             {
                 if (pPacket->pImage != NULL)
-                    add_to_map(pPacket->pImage, &img);
+                    add_to_map(pPacket->pImage, &local_imgObj);
                 if(pPacket->pMem != NULL)
-                    add_to_map(pPacket->pMem, &mem);
-                m_display->imageHandles.push_back(img);
-                m_display->imageMemory.push_back(mem);
+                    add_to_map(pPacket->pMem, &local_mem);
+                m_display->imageHandles.push_back(local_imgObj.replayImage);
+                m_display->imageMemory.push_back(local_mem.replayGpuMem);
             }
 #elif defined(WIN32)
             //TBD
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h
index d35a8af..df55449 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h
@@ -105,6 +105,18 @@
     XGL_GPU_SIZE size;
     void *pData;
 } XGLAllocInfo;
+
+class objMemory {
+public:
+    objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {}
+    ~objMemory() { free(m_pMemReqs);}
+    void setCount(const uint32_t num);
+    void setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num);
+private:
+    uint32_t m_numAllocations;
+    XGL_MEMORY_REQUIREMENTS *m_pMemReqs;
+};
+
 struct xglFuncs {
     void init_funcs(void * libHandle);
     void *m_libHandle;
@@ -806,6 +818,7 @@
     };
     std::vector<struct validationMsg> m_validationMsgs;
     std::vector<int> m_screenshotFrames;
+    // memory mapping functions for app writes into mapped memory
     std::map<XGL_GPU_MEMORY, XGLAllocInfo> m_mapData;
     void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)
     {
@@ -856,19 +869,63 @@
         info.pData = NULL;
     }
 
-    /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;
-    void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)
+    bool m_adjustForGPU; // true if replay adjusts behavior based on GPU
+    struct imageObj {
+       objMemory imageMem;
+       XGL_IMAGE replayImage;
+    };
+
+    struct bufferObj {
+       objMemory bufferMem;
+       XGL_BUFFER replayBuffer;
+    };
+
+    struct gpuMemObj {
+       objMemory gpuMem;
+       XGL_GPU_MEMORY replayGpuMem;
+    };
+
+    void init_objMemCount(const XGL_BASE_OBJECT& object, const uint32_t &num)
     {
-        assert(pTraceGpu != NULL);
-        assert(pReplayGpu != NULL);
-        m_gpus[*pTraceGpu] = *pReplayGpu;
+        XGL_IMAGE img = static_cast <XGL_IMAGE> (object);
+        std::map<XGL_IMAGE, struct imageObj>::const_iterator it = m_images.find(img);
+        if (it != m_images.end())
+        {
+            objMemory obj = it->second.imageMem;
+            obj.setCount(num);
+            return;
+        }
+        XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);
+        std::map<XGL_BUFFER, struct bufferObj>::const_iterator itb = m_buffers.find(buf);
+        if (itb != m_buffers.end())
+        {
+            objMemory obj = itb->second.bufferMem;
+            obj.setCount(num);
+            return;
+        }
+        return;
     }
 
-    XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)
+    void init_objMemReqs(const XGL_BASE_OBJECT& object, const XGL_MEMORY_REQUIREMENTS *pMemReqs, const unsigned int num)
     {
-        std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);
-        return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;
-    }*/
+        XGL_IMAGE img = static_cast <XGL_IMAGE> (object);
+        std::map<XGL_IMAGE, struct imageObj>::const_iterator it = m_images.find(img);
+        if (it != m_images.end())
+        {
+            objMemory obj = it->second.imageMem;
+            obj.setReqs(pMemReqs, num);
+            return;
+        }
+        XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);
+        std::map<XGL_BUFFER, struct bufferObj>::const_iterator itb = m_buffers.find(buf);
+        if (itb != m_buffers.end())
+        {
+            objMemory obj = itb->second.bufferMem;
+            obj.setReqs(pMemReqs, num);
+            return;
+        }
+        return;
+    }
 
     void clear_all_map_handles()
     {
@@ -902,6 +959,7 @@
         m_samplers.clear();
         m_shaders.clear();
     }
+
     std::map<XGL_BUFFER_VIEW, XGL_BUFFER_VIEW> m_bufferViews;
     void add_to_map(XGL_BUFFER_VIEW* pTraceVal, XGL_BUFFER_VIEW* pReplayVal)
     {
@@ -909,31 +967,37 @@
         assert(pReplayVal != NULL);
         m_bufferViews[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_BUFFER_VIEW& key)
     {
         m_bufferViews.erase(key);
     }
+
     XGL_BUFFER_VIEW remap(const XGL_BUFFER_VIEW& value)
     {
         std::map<XGL_BUFFER_VIEW, XGL_BUFFER_VIEW>::const_iterator q = m_bufferViews.find(value);
         return (q == m_bufferViews.end()) ? XGL_NULL_HANDLE : q->second;
     }
-    std::map<XGL_BUFFER, XGL_BUFFER> m_buffers;
-    void add_to_map(XGL_BUFFER* pTraceVal, XGL_BUFFER* pReplayVal)
+
+    std::map<XGL_BUFFER, struct bufferObj> m_buffers;
+    void add_to_map(XGL_BUFFER* pTraceVal, struct bufferObj* pReplayVal)
     {
         assert(pTraceVal != NULL);
         assert(pReplayVal != NULL);
         m_buffers[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_BUFFER& key)
     {
         m_buffers.erase(key);
     }
+
     XGL_BUFFER remap(const XGL_BUFFER& value)
     {
-        std::map<XGL_BUFFER, XGL_BUFFER>::const_iterator q = m_buffers.find(value);
-        return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second;
+        std::map<XGL_BUFFER, struct bufferObj>::const_iterator q = m_buffers.find(value);
+        return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second.replayBuffer;
     }
+
     std::map<XGL_CMD_BUFFER, XGL_CMD_BUFFER> m_cmdBuffers;
     void add_to_map(XGL_CMD_BUFFER* pTraceVal, XGL_CMD_BUFFER* pReplayVal)
     {
@@ -941,15 +1005,18 @@
         assert(pReplayVal != NULL);
         m_cmdBuffers[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_CMD_BUFFER& key)
     {
         m_cmdBuffers.erase(key);
     }
+
     XGL_CMD_BUFFER remap(const XGL_CMD_BUFFER& value)
     {
         std::map<XGL_CMD_BUFFER, XGL_CMD_BUFFER>::const_iterator q = m_cmdBuffers.find(value);
         return (q == m_cmdBuffers.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_COLOR_ATTACHMENT_VIEW, XGL_COLOR_ATTACHMENT_VIEW> m_colorAttachmentViews;
     void add_to_map(XGL_COLOR_ATTACHMENT_VIEW* pTraceVal, XGL_COLOR_ATTACHMENT_VIEW* pReplayVal)
     {
@@ -957,15 +1024,18 @@
         assert(pReplayVal != NULL);
         m_colorAttachmentViews[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_COLOR_ATTACHMENT_VIEW& key)
     {
         m_colorAttachmentViews.erase(key);
     }
+
     XGL_COLOR_ATTACHMENT_VIEW remap(const XGL_COLOR_ATTACHMENT_VIEW& value)
     {
         std::map<XGL_COLOR_ATTACHMENT_VIEW, XGL_COLOR_ATTACHMENT_VIEW>::const_iterator q = m_colorAttachmentViews.find(value);
         return (q == m_colorAttachmentViews.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DEPTH_STENCIL_VIEW, XGL_DEPTH_STENCIL_VIEW> m_depthStencilViews;
     void add_to_map(XGL_DEPTH_STENCIL_VIEW* pTraceVal, XGL_DEPTH_STENCIL_VIEW* pReplayVal)
     {
@@ -973,15 +1043,18 @@
         assert(pReplayVal != NULL);
         m_depthStencilViews[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DEPTH_STENCIL_VIEW& key)
     {
         m_depthStencilViews.erase(key);
     }
+
     XGL_DEPTH_STENCIL_VIEW remap(const XGL_DEPTH_STENCIL_VIEW& value)
     {
         std::map<XGL_DEPTH_STENCIL_VIEW, XGL_DEPTH_STENCIL_VIEW>::const_iterator q = m_depthStencilViews.find(value);
         return (q == m_depthStencilViews.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DESCRIPTOR_REGION, XGL_DESCRIPTOR_REGION> m_descriptorRegions;
     void add_to_map(XGL_DESCRIPTOR_REGION* pTraceVal, XGL_DESCRIPTOR_REGION* pReplayVal)
     {
@@ -989,15 +1062,18 @@
         assert(pReplayVal != NULL);
         m_descriptorRegions[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DESCRIPTOR_REGION& key)
     {
         m_descriptorRegions.erase(key);
     }
+
     XGL_DESCRIPTOR_REGION remap(const XGL_DESCRIPTOR_REGION& value)
     {
         std::map<XGL_DESCRIPTOR_REGION, XGL_DESCRIPTOR_REGION>::const_iterator q = m_descriptorRegions.find(value);
         return (q == m_descriptorRegions.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DESCRIPTOR_SET_LAYOUT, XGL_DESCRIPTOR_SET_LAYOUT> m_descriptorSetLayouts;
     void add_to_map(XGL_DESCRIPTOR_SET_LAYOUT* pTraceVal, XGL_DESCRIPTOR_SET_LAYOUT* pReplayVal)
     {
@@ -1005,15 +1081,18 @@
         assert(pReplayVal != NULL);
         m_descriptorSetLayouts[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DESCRIPTOR_SET_LAYOUT& key)
     {
         m_descriptorSetLayouts.erase(key);
     }
+
     XGL_DESCRIPTOR_SET_LAYOUT remap(const XGL_DESCRIPTOR_SET_LAYOUT& value)
     {
         std::map<XGL_DESCRIPTOR_SET_LAYOUT, XGL_DESCRIPTOR_SET_LAYOUT>::const_iterator q = m_descriptorSetLayouts.find(value);
         return (q == m_descriptorSetLayouts.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DESCRIPTOR_SET, XGL_DESCRIPTOR_SET> m_descriptorSets;
     void add_to_map(XGL_DESCRIPTOR_SET* pTraceVal, XGL_DESCRIPTOR_SET* pReplayVal)
     {
@@ -1021,15 +1100,18 @@
         assert(pReplayVal != NULL);
         m_descriptorSets[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DESCRIPTOR_SET& key)
     {
         m_descriptorSets.erase(key);
     }
+
     XGL_DESCRIPTOR_SET remap(const XGL_DESCRIPTOR_SET& value)
     {
         std::map<XGL_DESCRIPTOR_SET, XGL_DESCRIPTOR_SET>::const_iterator q = m_descriptorSets.find(value);
         return (q == m_descriptorSets.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DEVICE, XGL_DEVICE> m_devices;
     void add_to_map(XGL_DEVICE* pTraceVal, XGL_DEVICE* pReplayVal)
     {
@@ -1037,15 +1119,18 @@
         assert(pReplayVal != NULL);
         m_devices[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DEVICE& key)
     {
         m_devices.erase(key);
     }
+
     XGL_DEVICE remap(const XGL_DEVICE& value)
     {
         std::map<XGL_DEVICE, XGL_DEVICE>::const_iterator q = m_devices.find(value);
         return (q == m_devices.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_CB_STATE_OBJECT> m_dynamicCbStateObjects;
     void add_to_map(XGL_DYNAMIC_CB_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_CB_STATE_OBJECT* pReplayVal)
     {
@@ -1053,15 +1138,18 @@
         assert(pReplayVal != NULL);
         m_dynamicCbStateObjects[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DYNAMIC_CB_STATE_OBJECT& key)
     {
         m_dynamicCbStateObjects.erase(key);
     }
+
     XGL_DYNAMIC_CB_STATE_OBJECT remap(const XGL_DYNAMIC_CB_STATE_OBJECT& value)
     {
         std::map<XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_CB_STATE_OBJECT>::const_iterator q = m_dynamicCbStateObjects.find(value);
         return (q == m_dynamicCbStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_DS_STATE_OBJECT> m_dynamicDsStateObjects;
     void add_to_map(XGL_DYNAMIC_DS_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_DS_STATE_OBJECT* pReplayVal)
     {
@@ -1069,15 +1157,18 @@
         assert(pReplayVal != NULL);
         m_dynamicDsStateObjects[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DYNAMIC_DS_STATE_OBJECT& key)
     {
         m_dynamicDsStateObjects.erase(key);
     }
+
     XGL_DYNAMIC_DS_STATE_OBJECT remap(const XGL_DYNAMIC_DS_STATE_OBJECT& value)
     {
         std::map<XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_DS_STATE_OBJECT>::const_iterator q = m_dynamicDsStateObjects.find(value);
         return (q == m_dynamicDsStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_RS_STATE_OBJECT> m_dynamicRsStateObjects;
     void add_to_map(XGL_DYNAMIC_RS_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_RS_STATE_OBJECT* pReplayVal)
     {
@@ -1085,15 +1176,18 @@
         assert(pReplayVal != NULL);
         m_dynamicRsStateObjects[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DYNAMIC_RS_STATE_OBJECT& key)
     {
         m_dynamicRsStateObjects.erase(key);
     }
+
     XGL_DYNAMIC_RS_STATE_OBJECT remap(const XGL_DYNAMIC_RS_STATE_OBJECT& value)
     {
         std::map<XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_RS_STATE_OBJECT>::const_iterator q = m_dynamicRsStateObjects.find(value);
         return (q == m_dynamicRsStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_VP_STATE_OBJECT> m_dynamicVpStateObjects;
     void add_to_map(XGL_DYNAMIC_VP_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_VP_STATE_OBJECT* pReplayVal)
     {
@@ -1101,15 +1195,18 @@
         assert(pReplayVal != NULL);
         m_dynamicVpStateObjects[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_DYNAMIC_VP_STATE_OBJECT& key)
     {
         m_dynamicVpStateObjects.erase(key);
     }
+
     XGL_DYNAMIC_VP_STATE_OBJECT remap(const XGL_DYNAMIC_VP_STATE_OBJECT& value)
     {
         std::map<XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_VP_STATE_OBJECT>::const_iterator q = m_dynamicVpStateObjects.find(value);
         return (q == m_dynamicVpStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_EVENT, XGL_EVENT> m_events;
     void add_to_map(XGL_EVENT* pTraceVal, XGL_EVENT* pReplayVal)
     {
@@ -1117,15 +1214,18 @@
         assert(pReplayVal != NULL);
         m_events[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_EVENT& key)
     {
         m_events.erase(key);
     }
+
     XGL_EVENT remap(const XGL_EVENT& value)
     {
         std::map<XGL_EVENT, XGL_EVENT>::const_iterator q = m_events.find(value);
         return (q == m_events.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_FENCE, XGL_FENCE> m_fences;
     void add_to_map(XGL_FENCE* pTraceVal, XGL_FENCE* pReplayVal)
     {
@@ -1133,15 +1233,18 @@
         assert(pReplayVal != NULL);
         m_fences[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_FENCE& key)
     {
         m_fences.erase(key);
     }
+
     XGL_FENCE remap(const XGL_FENCE& value)
     {
         std::map<XGL_FENCE, XGL_FENCE>::const_iterator q = m_fences.find(value);
         return (q == m_fences.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_FRAMEBUFFER, XGL_FRAMEBUFFER> m_framebuffers;
     void add_to_map(XGL_FRAMEBUFFER* pTraceVal, XGL_FRAMEBUFFER* pReplayVal)
     {
@@ -1149,31 +1252,37 @@
         assert(pReplayVal != NULL);
         m_framebuffers[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_FRAMEBUFFER& key)
     {
         m_framebuffers.erase(key);
     }
+
     XGL_FRAMEBUFFER remap(const XGL_FRAMEBUFFER& value)
     {
         std::map<XGL_FRAMEBUFFER, XGL_FRAMEBUFFER>::const_iterator q = m_framebuffers.find(value);
         return (q == m_framebuffers.end()) ? XGL_NULL_HANDLE : q->second;
     }
-    std::map<XGL_GPU_MEMORY, XGL_GPU_MEMORY> m_gpuMemorys;
-    void add_to_map(XGL_GPU_MEMORY* pTraceVal, XGL_GPU_MEMORY* pReplayVal)
+
+    std::map<XGL_GPU_MEMORY, struct gpuMemObj> m_gpuMemorys;
+    void add_to_map(XGL_GPU_MEMORY* pTraceVal, struct gpuMemObj* pReplayVal)
     {
         assert(pTraceVal != NULL);
         assert(pReplayVal != NULL);
         m_gpuMemorys[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_GPU_MEMORY& key)
     {
         m_gpuMemorys.erase(key);
     }
+
     XGL_GPU_MEMORY remap(const XGL_GPU_MEMORY& value)
     {
-        std::map<XGL_GPU_MEMORY, XGL_GPU_MEMORY>::const_iterator q = m_gpuMemorys.find(value);
-        return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second;
+        std::map<XGL_GPU_MEMORY, struct gpuMemObj>::const_iterator q = m_gpuMemorys.find(value);
+        return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second.replayGpuMem;
     }
+
     std::map<XGL_IMAGE_VIEW, XGL_IMAGE_VIEW> m_imageViews;
     void add_to_map(XGL_IMAGE_VIEW* pTraceVal, XGL_IMAGE_VIEW* pReplayVal)
     {
@@ -1181,31 +1290,37 @@
         assert(pReplayVal != NULL);
         m_imageViews[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_IMAGE_VIEW& key)
     {
         m_imageViews.erase(key);
     }
+
     XGL_IMAGE_VIEW remap(const XGL_IMAGE_VIEW& value)
     {
         std::map<XGL_IMAGE_VIEW, XGL_IMAGE_VIEW>::const_iterator q = m_imageViews.find(value);
         return (q == m_imageViews.end()) ? XGL_NULL_HANDLE : q->second;
     }
-    std::map<XGL_IMAGE, XGL_IMAGE> m_images;
-    void add_to_map(XGL_IMAGE* pTraceVal, XGL_IMAGE* pReplayVal)
+
+    std::map<XGL_IMAGE, struct imageObj> m_images;
+    void add_to_map(XGL_IMAGE* pTraceVal, struct imageObj* pReplayVal)
     {
         assert(pTraceVal != NULL);
         assert(pReplayVal != NULL);
         m_images[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_IMAGE& key)
     {
         m_images.erase(key);
     }
+
     XGL_IMAGE remap(const XGL_IMAGE& value)
     {
-        std::map<XGL_IMAGE, XGL_IMAGE>::const_iterator q = m_images.find(value);
-        return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second;
+        std::map<XGL_IMAGE, struct imageObj>::const_iterator q = m_images.find(value);
+        return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second.replayImage;
     }
+
     std::map<XGL_INSTANCE, XGL_INSTANCE> m_instances;
     void add_to_map(XGL_INSTANCE* pTraceVal, XGL_INSTANCE* pReplayVal)
     {
@@ -1213,15 +1328,18 @@
         assert(pReplayVal != NULL);
         m_instances[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_INSTANCE& key)
     {
         m_instances.erase(key);
     }
+
     XGL_INSTANCE remap(const XGL_INSTANCE& value)
     {
         std::map<XGL_INSTANCE, XGL_INSTANCE>::const_iterator q = m_instances.find(value);
         return (q == m_instances.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_physicalGpus;
     void add_to_map(XGL_PHYSICAL_GPU* pTraceVal, XGL_PHYSICAL_GPU* pReplayVal)
     {
@@ -1229,15 +1347,18 @@
         assert(pReplayVal != NULL);
         m_physicalGpus[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_PHYSICAL_GPU& key)
     {
         m_physicalGpus.erase(key);
     }
+
     XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& value)
     {
         std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_physicalGpus.find(value);
         return (q == m_physicalGpus.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_PIPELINE_DELTA, XGL_PIPELINE_DELTA> m_pipelineDeltas;
     void add_to_map(XGL_PIPELINE_DELTA* pTraceVal, XGL_PIPELINE_DELTA* pReplayVal)
     {
@@ -1245,15 +1366,18 @@
         assert(pReplayVal != NULL);
         m_pipelineDeltas[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_PIPELINE_DELTA& key)
     {
         m_pipelineDeltas.erase(key);
     }
+
     XGL_PIPELINE_DELTA remap(const XGL_PIPELINE_DELTA& value)
     {
         std::map<XGL_PIPELINE_DELTA, XGL_PIPELINE_DELTA>::const_iterator q = m_pipelineDeltas.find(value);
         return (q == m_pipelineDeltas.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_PIPELINE, XGL_PIPELINE> m_pipelines;
     void add_to_map(XGL_PIPELINE* pTraceVal, XGL_PIPELINE* pReplayVal)
     {
@@ -1261,15 +1385,18 @@
         assert(pReplayVal != NULL);
         m_pipelines[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_PIPELINE& key)
     {
         m_pipelines.erase(key);
     }
+
     XGL_PIPELINE remap(const XGL_PIPELINE& value)
     {
         std::map<XGL_PIPELINE, XGL_PIPELINE>::const_iterator q = m_pipelines.find(value);
         return (q == m_pipelines.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_QUERY_POOL, XGL_QUERY_POOL> m_queryPools;
     void add_to_map(XGL_QUERY_POOL* pTraceVal, XGL_QUERY_POOL* pReplayVal)
     {
@@ -1277,15 +1404,18 @@
         assert(pReplayVal != NULL);
         m_queryPools[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_QUERY_POOL& key)
     {
         m_queryPools.erase(key);
     }
+
     XGL_QUERY_POOL remap(const XGL_QUERY_POOL& value)
     {
         std::map<XGL_QUERY_POOL, XGL_QUERY_POOL>::const_iterator q = m_queryPools.find(value);
         return (q == m_queryPools.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_QUEUE_SEMAPHORE, XGL_QUEUE_SEMAPHORE> m_queueSemaphores;
     void add_to_map(XGL_QUEUE_SEMAPHORE* pTraceVal, XGL_QUEUE_SEMAPHORE* pReplayVal)
     {
@@ -1293,15 +1423,18 @@
         assert(pReplayVal != NULL);
         m_queueSemaphores[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_QUEUE_SEMAPHORE& key)
     {
         m_queueSemaphores.erase(key);
     }
+
     XGL_QUEUE_SEMAPHORE remap(const XGL_QUEUE_SEMAPHORE& value)
     {
         std::map<XGL_QUEUE_SEMAPHORE, XGL_QUEUE_SEMAPHORE>::const_iterator q = m_queueSemaphores.find(value);
         return (q == m_queueSemaphores.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_QUEUE, XGL_QUEUE> m_queues;
     void add_to_map(XGL_QUEUE* pTraceVal, XGL_QUEUE* pReplayVal)
     {
@@ -1309,15 +1442,18 @@
         assert(pReplayVal != NULL);
         m_queues[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_QUEUE& key)
     {
         m_queues.erase(key);
     }
+
     XGL_QUEUE remap(const XGL_QUEUE& value)
     {
         std::map<XGL_QUEUE, XGL_QUEUE>::const_iterator q = m_queues.find(value);
         return (q == m_queues.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_RENDER_PASS, XGL_RENDER_PASS> m_renderPasss;
     void add_to_map(XGL_RENDER_PASS* pTraceVal, XGL_RENDER_PASS* pReplayVal)
     {
@@ -1325,15 +1461,18 @@
         assert(pReplayVal != NULL);
         m_renderPasss[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_RENDER_PASS& key)
     {
         m_renderPasss.erase(key);
     }
+
     XGL_RENDER_PASS remap(const XGL_RENDER_PASS& value)
     {
         std::map<XGL_RENDER_PASS, XGL_RENDER_PASS>::const_iterator q = m_renderPasss.find(value);
         return (q == m_renderPasss.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_SAMPLER, XGL_SAMPLER> m_samplers;
     void add_to_map(XGL_SAMPLER* pTraceVal, XGL_SAMPLER* pReplayVal)
     {
@@ -1341,15 +1480,18 @@
         assert(pReplayVal != NULL);
         m_samplers[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_SAMPLER& key)
     {
         m_samplers.erase(key);
     }
+
     XGL_SAMPLER remap(const XGL_SAMPLER& value)
     {
         std::map<XGL_SAMPLER, XGL_SAMPLER>::const_iterator q = m_samplers.find(value);
         return (q == m_samplers.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     std::map<XGL_SHADER, XGL_SHADER> m_shaders;
     void add_to_map(XGL_SHADER* pTraceVal, XGL_SHADER* pReplayVal)
     {
@@ -1357,15 +1499,18 @@
         assert(pReplayVal != NULL);
         m_shaders[*pTraceVal] = *pReplayVal;
     }
+
     void rm_from_map(const XGL_SHADER& key)
     {
         m_shaders.erase(key);
     }
+
     XGL_SHADER remap(const XGL_SHADER& value)
     {
         std::map<XGL_SHADER, XGL_SHADER>::const_iterator q = m_shaders.find(value);
         return (q == m_shaders.end()) ? XGL_NULL_HANDLE : q->second;
     }
+
     XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)
     {
         XGL_DYNAMIC_STATE_OBJECT obj;
@@ -1386,6 +1531,7 @@
         rm_from_map(static_cast <XGL_DYNAMIC_CB_STATE_OBJECT> (state));
         rm_from_map(static_cast <XGL_DYNAMIC_DS_STATE_OBJECT> (state));
     }
+
     XGL_OBJECT remap(const XGL_OBJECT& object)
     {
         XGL_OBJECT obj;
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h
deleted file mode 100644
index d1dded3..0000000
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h
+++ /dev/null
@@ -1,1475 +0,0 @@
-/* THIS FILE IS GENERATED.  DO NOT EDIT. */
-
-/*
- * XGL
- *
- * Copyright (C) 2014 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#pragma once
-
-#include "glv_trace_packet_utils.h"
-#include "glv_trace_packet_identifiers.h"
-#include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
-#include "xgl_enum_string_helper.h"
-#if defined(WIN32)
-#define snprintf _snprintf
-#endif
-#define SEND_ENTRYPOINT_ID(entrypoint) ;
-//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\n");
-
-#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;
-//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);
-
-#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \
-    pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);
-
-#define FINISH_TRACE_PACKET() \
-    glv_finalize_trace_packet(pHeader); \
-    glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \
-    glv_delete_trace_packet(&pHeader);
-
-enum GLV_TRACE_PACKET_ID_XGL
-{
-    GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,
-    GLV_TPI_XGL_xglCreateInstance,
-    GLV_TPI_XGL_xglDestroyInstance,
-    GLV_TPI_XGL_xglEnumerateGpus,
-    GLV_TPI_XGL_xglGetGpuInfo,
-    GLV_TPI_XGL_xglGetProcAddr,
-    GLV_TPI_XGL_xglCreateDevice,
-    GLV_TPI_XGL_xglDestroyDevice,
-    GLV_TPI_XGL_xglGetExtensionSupport,
-    GLV_TPI_XGL_xglEnumerateLayers,
-    GLV_TPI_XGL_xglGetDeviceQueue,
-    GLV_TPI_XGL_xglQueueSubmit,
-    GLV_TPI_XGL_xglQueueSetGlobalMemReferences,
-    GLV_TPI_XGL_xglQueueWaitIdle,
-    GLV_TPI_XGL_xglDeviceWaitIdle,
-    GLV_TPI_XGL_xglAllocMemory,
-    GLV_TPI_XGL_xglFreeMemory,
-    GLV_TPI_XGL_xglSetMemoryPriority,
-    GLV_TPI_XGL_xglMapMemory,
-    GLV_TPI_XGL_xglUnmapMemory,
-    GLV_TPI_XGL_xglPinSystemMemory,
-    GLV_TPI_XGL_xglGetMultiGpuCompatibility,
-    GLV_TPI_XGL_xglOpenSharedMemory,
-    GLV_TPI_XGL_xglOpenSharedQueueSemaphore,
-    GLV_TPI_XGL_xglOpenPeerMemory,
-    GLV_TPI_XGL_xglOpenPeerImage,
-    GLV_TPI_XGL_xglDestroyObject,
-    GLV_TPI_XGL_xglGetObjectInfo,
-    GLV_TPI_XGL_xglBindObjectMemory,
-    GLV_TPI_XGL_xglBindObjectMemoryRange,
-    GLV_TPI_XGL_xglBindImageMemoryRange,
-    GLV_TPI_XGL_xglCreateFence,
-    GLV_TPI_XGL_xglGetFenceStatus,
-    GLV_TPI_XGL_xglWaitForFences,
-    GLV_TPI_XGL_xglCreateQueueSemaphore,
-    GLV_TPI_XGL_xglSignalQueueSemaphore,
-    GLV_TPI_XGL_xglWaitQueueSemaphore,
-    GLV_TPI_XGL_xglCreateEvent,
-    GLV_TPI_XGL_xglGetEventStatus,
-    GLV_TPI_XGL_xglSetEvent,
-    GLV_TPI_XGL_xglResetEvent,
-    GLV_TPI_XGL_xglCreateQueryPool,
-    GLV_TPI_XGL_xglGetQueryPoolResults,
-    GLV_TPI_XGL_xglGetFormatInfo,
-    GLV_TPI_XGL_xglCreateBuffer,
-    GLV_TPI_XGL_xglCreateBufferView,
-    GLV_TPI_XGL_xglCreateImage,
-    GLV_TPI_XGL_xglSetFastClearColor,
-    GLV_TPI_XGL_xglSetFastClearDepth,
-    GLV_TPI_XGL_xglGetImageSubresourceInfo,
-    GLV_TPI_XGL_xglCreateImageView,
-    GLV_TPI_XGL_xglCreateColorAttachmentView,
-    GLV_TPI_XGL_xglCreateDepthStencilView,
-    GLV_TPI_XGL_xglCreateShader,
-    GLV_TPI_XGL_xglCreateGraphicsPipeline,
-    GLV_TPI_XGL_xglCreateComputePipeline,
-    GLV_TPI_XGL_xglStorePipeline,
-    GLV_TPI_XGL_xglLoadPipeline,
-    GLV_TPI_XGL_xglCreatePipelineDelta,
-    GLV_TPI_XGL_xglCreateSampler,
-    GLV_TPI_XGL_xglCreateDescriptorSetLayout,
-    GLV_TPI_XGL_xglBeginDescriptorRegionUpdate,
-    GLV_TPI_XGL_xglEndDescriptorRegionUpdate,
-    GLV_TPI_XGL_xglCreateDescriptorRegion,
-    GLV_TPI_XGL_xglClearDescriptorRegion,
-    GLV_TPI_XGL_xglAllocDescriptorSets,
-    GLV_TPI_XGL_xglClearDescriptorSets,
-    GLV_TPI_XGL_xglUpdateDescriptors,
-    GLV_TPI_XGL_xglCreateDynamicViewportState,
-    GLV_TPI_XGL_xglCreateDynamicRasterState,
-    GLV_TPI_XGL_xglCreateDynamicColorBlendState,
-    GLV_TPI_XGL_xglCreateDynamicDepthStencilState,
-    GLV_TPI_XGL_xglCreateCommandBuffer,
-    GLV_TPI_XGL_xglBeginCommandBuffer,
-    GLV_TPI_XGL_xglEndCommandBuffer,
-    GLV_TPI_XGL_xglResetCommandBuffer,
-    GLV_TPI_XGL_xglCmdBindPipeline,
-    GLV_TPI_XGL_xglCmdBindPipelineDelta,
-    GLV_TPI_XGL_xglCmdBindDynamicStateObject,
-    GLV_TPI_XGL_xglCmdBindDescriptorSet,
-    GLV_TPI_XGL_xglCmdBindVertexBuffer,
-    GLV_TPI_XGL_xglCmdBindIndexBuffer,
-    GLV_TPI_XGL_xglCmdDraw,
-    GLV_TPI_XGL_xglCmdDrawIndexed,
-    GLV_TPI_XGL_xglCmdDrawIndirect,
-    GLV_TPI_XGL_xglCmdDrawIndexedIndirect,
-    GLV_TPI_XGL_xglCmdDispatch,
-    GLV_TPI_XGL_xglCmdDispatchIndirect,
-    GLV_TPI_XGL_xglCmdCopyBuffer,
-    GLV_TPI_XGL_xglCmdCopyImage,
-    GLV_TPI_XGL_xglCmdCopyBufferToImage,
-    GLV_TPI_XGL_xglCmdCopyImageToBuffer,
-    GLV_TPI_XGL_xglCmdCloneImageData,
-    GLV_TPI_XGL_xglCmdUpdateBuffer,
-    GLV_TPI_XGL_xglCmdFillBuffer,
-    GLV_TPI_XGL_xglCmdClearColorImage,
-    GLV_TPI_XGL_xglCmdClearColorImageRaw,
-    GLV_TPI_XGL_xglCmdClearDepthStencil,
-    GLV_TPI_XGL_xglCmdResolveImage,
-    GLV_TPI_XGL_xglCmdSetEvent,
-    GLV_TPI_XGL_xglCmdResetEvent,
-    GLV_TPI_XGL_xglCmdWaitEvents,
-    GLV_TPI_XGL_xglCmdPipelineBarrier,
-    GLV_TPI_XGL_xglCmdBeginQuery,
-    GLV_TPI_XGL_xglCmdEndQuery,
-    GLV_TPI_XGL_xglCmdResetQueryPool,
-    GLV_TPI_XGL_xglCmdWriteTimestamp,
-    GLV_TPI_XGL_xglCmdInitAtomicCounters,
-    GLV_TPI_XGL_xglCmdLoadAtomicCounters,
-    GLV_TPI_XGL_xglCmdSaveAtomicCounters,
-    GLV_TPI_XGL_xglCreateFramebuffer,
-    GLV_TPI_XGL_xglCreateRenderPass,
-    GLV_TPI_XGL_xglCmdBeginRenderPass,
-    GLV_TPI_XGL_xglCmdEndRenderPass,
-    GLV_TPI_XGL_xglDbgSetValidationLevel,
-    GLV_TPI_XGL_xglDbgRegisterMsgCallback,
-    GLV_TPI_XGL_xglDbgUnregisterMsgCallback,
-    GLV_TPI_XGL_xglDbgSetMessageFilter,
-    GLV_TPI_XGL_xglDbgSetObjectTag,
-    GLV_TPI_XGL_xglDbgSetGlobalOption,
-    GLV_TPI_XGL_xglDbgSetDeviceOption,
-    GLV_TPI_XGL_xglCmdDbgMarkerBegin,
-    GLV_TPI_XGL_xglCmdDbgMarkerEnd,
-    GLV_TPI_XGL_xglWsiX11AssociateConnection,
-    GLV_TPI_XGL_xglWsiX11GetMSC,
-    GLV_TPI_XGL_xglWsiX11CreatePresentableImage,
-    GLV_TPI_XGL_xglWsiX11QueuePresent,
-};
-
-static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)
-{
-    static char str[1024];
-    switch(id) {
-    case GLV_TPI_XGL_xglApiVersion:
-    {
-        struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);
-        snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateInstance:
-    {
-        struct_xglCreateInstance* pPacket = (struct_xglCreateInstance*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateInstance(pAppInfo = %p, pAllocCb = %p, pInstance = %p)", (void*)(pPacket->pAppInfo), (void*)(pPacket->pAllocCb), (void*)pPacket->pInstance);
-        return str;
-    }
-    case GLV_TPI_XGL_xglDestroyInstance:
-    {
-        struct_xglDestroyInstance* pPacket = (struct_xglDestroyInstance*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDestroyInstance(instance = %p)", (void*)(pPacket->instance));
-        return str;
-    }
-    case GLV_TPI_XGL_xglEnumerateGpus:
-    {
-        struct_xglEnumerateGpus* pPacket = (struct_xglEnumerateGpus*)(pHeader->pBody);
-        snprintf(str, 1024, "xglEnumerateGpus(instance = %p, maxGpus = %i, *pGpuCount = %i, pGpus = %p)", (void*)(pPacket->instance), pPacket->maxGpus, (pPacket->pGpuCount == NULL) ? 0 : *(pPacket->pGpuCount), (void*)(pPacket->pGpus));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetGpuInfo:
-    {
-        struct_xglGetGpuInfo* pPacket = (struct_xglGetGpuInfo*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetGpuInfo(gpu = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->gpu), string_XGL_PHYSICAL_GPU_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetProcAddr:
-    {
-        struct_xglGetProcAddr* pPacket = (struct_xglGetProcAddr*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetProcAddr(gpu = %p, pName = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pName));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDevice:
-    {
-        struct_xglCreateDevice* pPacket = (struct_xglCreateDevice*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDevice(gpu = %p, pCreateInfo = %p, pDevice = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pCreateInfo), (void*)pPacket->pDevice);
-        return str;
-    }
-    case GLV_TPI_XGL_xglDestroyDevice:
-    {
-        struct_xglDestroyDevice* pPacket = (struct_xglDestroyDevice*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDestroyDevice(device = %p)", (void*)(pPacket->device));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetExtensionSupport:
-    {
-        struct_xglGetExtensionSupport* pPacket = (struct_xglGetExtensionSupport*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetExtensionSupport(gpu = %p, pExtName = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pExtName));
-        return str;
-    }
-    case GLV_TPI_XGL_xglEnumerateLayers:
-    {
-        struct_xglEnumerateLayers* pPacket = (struct_xglEnumerateLayers*)(pHeader->pBody);
-        snprintf(str, 1024, "xglEnumerateLayers(gpu = %p, maxLayerCount = %zu, maxStringSize = %zu, *pOutLayerCount = %zu, pOutLayers = %p, pReserved = %p)", (void*)(pPacket->gpu), pPacket->maxLayerCount, pPacket->maxStringSize, (pPacket->pOutLayerCount == NULL) ? 0 : *(pPacket->pOutLayerCount), (void*)(pPacket->pOutLayers), (void*)(pPacket->pReserved));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetDeviceQueue:
-    {
-        struct_xglGetDeviceQueue* pPacket = (struct_xglGetDeviceQueue*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetDeviceQueue(device = %p, queueType = %s, queueIndex = %i, pQueue = %p)", (void*)(pPacket->device), string_XGL_QUEUE_TYPE(pPacket->queueType), pPacket->queueIndex, (void*)(pPacket->pQueue));
-        return str;
-    }
-    case GLV_TPI_XGL_xglQueueSubmit:
-    {
-        struct_xglQueueSubmit* pPacket = (struct_xglQueueSubmit*)(pHeader->pBody);
-        snprintf(str, 1024, "xglQueueSubmit(queue = %p, cmdBufferCount = %i, pCmdBuffers = %p, memRefCount = %i, pMemRefs = %p, fence = %p)", (void*)(pPacket->queue), pPacket->cmdBufferCount, (void*)(pPacket->pCmdBuffers), pPacket->memRefCount, (void*)(pPacket->pMemRefs), (void*)(pPacket->fence));
-        return str;
-    }
-    case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
-    {
-        struct_xglQueueSetGlobalMemReferences* pPacket = (struct_xglQueueSetGlobalMemReferences*)(pHeader->pBody);
-        snprintf(str, 1024, "xglQueueSetGlobalMemReferences(queue = %p, memRefCount = %i, pMemRefs = %p)", (void*)(pPacket->queue), pPacket->memRefCount, (void*)(pPacket->pMemRefs));
-        return str;
-    }
-    case GLV_TPI_XGL_xglQueueWaitIdle:
-    {
-        struct_xglQueueWaitIdle* pPacket = (struct_xglQueueWaitIdle*)(pHeader->pBody);
-        snprintf(str, 1024, "xglQueueWaitIdle(queue = %p)", (void*)(pPacket->queue));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDeviceWaitIdle:
-    {
-        struct_xglDeviceWaitIdle* pPacket = (struct_xglDeviceWaitIdle*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDeviceWaitIdle(device = %p)", (void*)(pPacket->device));
-        return str;
-    }
-    case GLV_TPI_XGL_xglAllocMemory:
-    {
-        struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglAllocMemory(device = %p, pAllocInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pAllocInfo), (void*)pPacket->pMem);
-        return str;
-    }
-    case GLV_TPI_XGL_xglFreeMemory:
-    {
-        struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglFreeMemory(mem = %p)", (void*)(pPacket->mem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglSetMemoryPriority:
-    {
-        struct_xglSetMemoryPriority* pPacket = (struct_xglSetMemoryPriority*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSetMemoryPriority(mem = %p, priority = %p)", (void*)(pPacket->mem), (void*)(pPacket->priority));
-        return str;
-    }
-    case GLV_TPI_XGL_xglMapMemory:
-    {
-        struct_xglMapMemory* pPacket = (struct_xglMapMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglMapMemory(mem = %p, flags = %i, ppData = %p)", (void*)(pPacket->mem), pPacket->flags, (void*)pPacket->ppData);
-        return str;
-    }
-    case GLV_TPI_XGL_xglUnmapMemory:
-    {
-        struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglUnmapMemory(mem = %p)", (void*)(pPacket->mem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglPinSystemMemory:
-    {
-        struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglPinSystemMemory(device = %p, pSysMem = %p, memSize = %zu, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pSysMem), pPacket->memSize, (void*)(pPacket->pMem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
-    {
-        struct_xglGetMultiGpuCompatibility* pPacket = (struct_xglGetMultiGpuCompatibility*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetMultiGpuCompatibility(gpu0 = %p, gpu1 = %p, pInfo = %p)", (void*)(pPacket->gpu0), (void*)(pPacket->gpu1), (void*)(pPacket->pInfo));
-        return str;
-    }
-    case GLV_TPI_XGL_xglOpenSharedMemory:
-    {
-        struct_xglOpenSharedMemory* pPacket = (struct_xglOpenSharedMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglOpenSharedMemory(device = %p, pOpenInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pMem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
-    {
-        struct_xglOpenSharedQueueSemaphore* pPacket = (struct_xglOpenSharedQueueSemaphore*)(pHeader->pBody);
-        snprintf(str, 1024, "xglOpenSharedQueueSemaphore(device = %p, pOpenInfo = %p, pSemaphore = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pSemaphore));
-        return str;
-    }
-    case GLV_TPI_XGL_xglOpenPeerMemory:
-    {
-        struct_xglOpenPeerMemory* pPacket = (struct_xglOpenPeerMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglOpenPeerMemory(device = %p, pOpenInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pMem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglOpenPeerImage:
-    {
-        struct_xglOpenPeerImage* pPacket = (struct_xglOpenPeerImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglOpenPeerImage(device = %p, pOpenInfo = %p, pImage = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pImage), (void*)(pPacket->pMem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDestroyObject:
-    {
-        struct_xglDestroyObject* pPacket = (struct_xglDestroyObject*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDestroyObject(object = %p)", (void*)(pPacket->object));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetObjectInfo:
-    {
-        struct_xglGetObjectInfo* pPacket = (struct_xglGetObjectInfo*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetObjectInfo(object = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->object), string_XGL_OBJECT_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglBindObjectMemory:
-    {
-        struct_xglBindObjectMemory* pPacket = (struct_xglBindObjectMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBindObjectMemory(object = %p, allocationIdx = %i, mem = %p, offset = %p)", (void*)(pPacket->object), pPacket->allocationIdx, (void*)(pPacket->mem), (void*)(pPacket->offset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglBindObjectMemoryRange:
-    {
-        struct_xglBindObjectMemoryRange* pPacket = (struct_xglBindObjectMemoryRange*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBindObjectMemoryRange(object = %p, allocationIdx = %i, rangeOffset = %p, rangeSize = %p, mem = %p, memOffset = %p)", (void*)(pPacket->object), pPacket->allocationIdx, (void*)(pPacket->rangeOffset), (void*)(pPacket->rangeSize), (void*)(pPacket->mem), (void*)(pPacket->memOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglBindImageMemoryRange:
-    {
-        struct_xglBindImageMemoryRange* pPacket = (struct_xglBindImageMemoryRange*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBindImageMemoryRange(image = %p, allocationIdx = %i, bindInfo = %p, mem = %p, memOffset = %p)", (void*)(pPacket->image), pPacket->allocationIdx, (void*)(pPacket->bindInfo), (void*)(pPacket->mem), (void*)(pPacket->memOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateFence:
-    {
-        struct_xglCreateFence* pPacket = (struct_xglCreateFence*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateFence(device = %p, pCreateInfo = %p, pFence = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pFence);
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetFenceStatus:
-    {
-        struct_xglGetFenceStatus* pPacket = (struct_xglGetFenceStatus*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetFenceStatus(fence = %p)", (void*)(pPacket->fence));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWaitForFences:
-    {
-        struct_xglWaitForFences* pPacket = (struct_xglWaitForFences*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWaitForFences(device = %p, fenceCount = %i, pFences = %p, waitAll = %u, timeout = %lu)", (void*)(pPacket->device), pPacket->fenceCount, (void*)(pPacket->pFences), pPacket->waitAll, pPacket->timeout);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateQueueSemaphore:
-    {
-        struct_xglCreateQueueSemaphore* pPacket = (struct_xglCreateQueueSemaphore*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateQueueSemaphore(device = %p, pCreateInfo = %p, pSemaphore = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pSemaphore);
-        return str;
-    }
-    case GLV_TPI_XGL_xglSignalQueueSemaphore:
-    {
-        struct_xglSignalQueueSemaphore* pPacket = (struct_xglSignalQueueSemaphore*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSignalQueueSemaphore(queue = %p, semaphore = %p)", (void*)(pPacket->queue), (void*)(pPacket->semaphore));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWaitQueueSemaphore:
-    {
-        struct_xglWaitQueueSemaphore* pPacket = (struct_xglWaitQueueSemaphore*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWaitQueueSemaphore(queue = %p, semaphore = %p)", (void*)(pPacket->queue), (void*)(pPacket->semaphore));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateEvent:
-    {
-        struct_xglCreateEvent* pPacket = (struct_xglCreateEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateEvent(device = %p, pCreateInfo = %p, pEvent = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pEvent);
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetEventStatus:
-    {
-        struct_xglGetEventStatus* pPacket = (struct_xglGetEventStatus*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetEventStatus(event = %p)", (void*)(pPacket->event));
-        return str;
-    }
-    case GLV_TPI_XGL_xglSetEvent:
-    {
-        struct_xglSetEvent* pPacket = (struct_xglSetEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSetEvent(event = %p)", (void*)(pPacket->event));
-        return str;
-    }
-    case GLV_TPI_XGL_xglResetEvent:
-    {
-        struct_xglResetEvent* pPacket = (struct_xglResetEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglResetEvent(event = %p)", (void*)(pPacket->event));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateQueryPool:
-    {
-        struct_xglCreateQueryPool* pPacket = (struct_xglCreateQueryPool*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateQueryPool(device = %p, pCreateInfo = %p, pQueryPool = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pQueryPool);
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetQueryPoolResults:
-    {
-        struct_xglGetQueryPoolResults* pPacket = (struct_xglGetQueryPoolResults*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetQueryPoolResults(queryPool = %p, startQuery = %i, queryCount = %i, *pDataSize = %zu, pData = %p)", (void*)(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount, (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetFormatInfo:
-    {
-        struct_xglGetFormatInfo* pPacket = (struct_xglGetFormatInfo*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetFormatInfo(device = %p, format = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->device), (void*)(pPacket->format), string_XGL_FORMAT_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateBuffer:
-    {
-        struct_xglCreateBuffer* pPacket = (struct_xglCreateBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateBuffer(device = %p, pCreateInfo = %p, pBuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pBuffer);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateBufferView:
-    {
-        struct_xglCreateBufferView* pPacket = (struct_xglCreateBufferView*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateBufferView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateImage:
-    {
-        struct_xglCreateImage* pPacket = (struct_xglCreateImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateImage(device = %p, pCreateInfo = %p, pImage = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pImage);
-        return str;
-    }
-    case GLV_TPI_XGL_xglSetFastClearColor:
-    {
-        struct_xglSetFastClearColor* pPacket = (struct_xglSetFastClearColor*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSetFastClearColor(image = %p, color = [%f, %f, %f, %f])", (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3]);
-        return str;
-    }
-    case GLV_TPI_XGL_xglSetFastClearDepth:
-    {
-        struct_xglSetFastClearDepth* pPacket = (struct_xglSetFastClearDepth*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSetFastClearDepth(image = %p, depth = %f)", (void*)(pPacket->image), pPacket->depth);
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetImageSubresourceInfo:
-    {
-        struct_xglGetImageSubresourceInfo* pPacket = (struct_xglGetImageSubresourceInfo*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetImageSubresourceInfo(image = %p, pSubresource = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->image), (void*)(pPacket->pSubresource), string_XGL_SUBRESOURCE_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateImageView:
-    {
-        struct_xglCreateImageView* pPacket = (struct_xglCreateImageView*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateImageView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateColorAttachmentView:
-    {
-        struct_xglCreateColorAttachmentView* pPacket = (struct_xglCreateColorAttachmentView*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateColorAttachmentView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDepthStencilView:
-    {
-        struct_xglCreateDepthStencilView* pPacket = (struct_xglCreateDepthStencilView*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDepthStencilView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateShader:
-    {
-        struct_xglCreateShader* pPacket = (struct_xglCreateShader*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateShader(device = %p, pCreateInfo = %p, pShader = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pShader);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateGraphicsPipeline:
-    {
-        struct_xglCreateGraphicsPipeline* pPacket = (struct_xglCreateGraphicsPipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateGraphicsPipeline(device = %p, pCreateInfo = %p, pPipeline = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pPipeline);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateComputePipeline:
-    {
-        struct_xglCreateComputePipeline* pPacket = (struct_xglCreateComputePipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateComputePipeline(device = %p, pCreateInfo = %p, pPipeline = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pPipeline);
-        return str;
-    }
-    case GLV_TPI_XGL_xglStorePipeline:
-    {
-        struct_xglStorePipeline* pPacket = (struct_xglStorePipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglStorePipeline(pipeline = %p, *pDataSize = %zu, pData = %p)", (void*)(pPacket->pipeline), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglLoadPipeline:
-    {
-        struct_xglLoadPipeline* pPacket = (struct_xglLoadPipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglLoadPipeline(device = %p, dataSize = %zu, pData = %p, pPipeline = %p)", (void*)(pPacket->device), pPacket->dataSize, (void*)(pPacket->pData), (void*)(pPacket->pPipeline));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreatePipelineDelta:
-    {
-        struct_xglCreatePipelineDelta* pPacket = (struct_xglCreatePipelineDelta*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreatePipelineDelta(device = %p, p1 = %p, p2 = %p, delta = %p)", (void*)(pPacket->device), (void*)(pPacket->p1), (void*)(pPacket->p2), (void*)pPacket->delta);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateSampler:
-    {
-        struct_xglCreateSampler* pPacket = (struct_xglCreateSampler*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateSampler(device = %p, pCreateInfo = %p, pSampler = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pSampler);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
-    {
-        struct_xglCreateDescriptorSetLayout* pPacket = (struct_xglCreateDescriptorSetLayout*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDescriptorSetLayout(device = %p, stageFlags = %i, *pSetBindPoints = %i, priorSetLayout = %p, pSetLayoutInfoList = %p, pSetLayout = %p)", (void*)(pPacket->device), pPacket->stageFlags, (pPacket->pSetBindPoints == NULL) ? 0 : *(pPacket->pSetBindPoints), (void*)(pPacket->priorSetLayout), (void*)(pPacket->pSetLayoutInfoList), (void*)pPacket->pSetLayout);
-        return str;
-    }
-    case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
-    {
-        struct_xglBeginDescriptorRegionUpdate* pPacket = (struct_xglBeginDescriptorRegionUpdate*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBeginDescriptorRegionUpdate(device = %p, updateMode = %p)", (void*)(pPacket->device), (void*)(pPacket->updateMode));
-        return str;
-    }
-    case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
-    {
-        struct_xglEndDescriptorRegionUpdate* pPacket = (struct_xglEndDescriptorRegionUpdate*)(pHeader->pBody);
-        snprintf(str, 1024, "xglEndDescriptorRegionUpdate(device = %p, cmd = %p)", (void*)(pPacket->device), (void*)(pPacket->cmd));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDescriptorRegion:
-    {
-        struct_xglCreateDescriptorRegion* pPacket = (struct_xglCreateDescriptorRegion*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDescriptorRegion(device = %p, regionUsage = %p, maxSets = %i, pCreateInfo = %p, pDescriptorRegion = %p)", (void*)(pPacket->device), (void*)(pPacket->regionUsage), pPacket->maxSets, (void*)(pPacket->pCreateInfo), (void*)pPacket->pDescriptorRegion);
-        return str;
-    }
-    case GLV_TPI_XGL_xglClearDescriptorRegion:
-    {
-        struct_xglClearDescriptorRegion* pPacket = (struct_xglClearDescriptorRegion*)(pHeader->pBody);
-        snprintf(str, 1024, "xglClearDescriptorRegion(descriptorRegion = %p)", (void*)(pPacket->descriptorRegion));
-        return str;
-    }
-    case GLV_TPI_XGL_xglAllocDescriptorSets:
-    {
-        struct_xglAllocDescriptorSets* pPacket = (struct_xglAllocDescriptorSets*)(pHeader->pBody);
-        snprintf(str, 1024, "xglAllocDescriptorSets(descriptorRegion = %p, setUsage = %p, count = %i, pSetLayouts = %p, pDescriptorSets = %p, *pCount = %i)", (void*)(pPacket->descriptorRegion), (void*)(pPacket->setUsage), pPacket->count, (void*)(pPacket->pSetLayouts), (void*)(pPacket->pDescriptorSets), (pPacket->pCount == NULL) ? 0 : *(pPacket->pCount));
-        return str;
-    }
-    case GLV_TPI_XGL_xglClearDescriptorSets:
-    {
-        struct_xglClearDescriptorSets* pPacket = (struct_xglClearDescriptorSets*)(pHeader->pBody);
-        snprintf(str, 1024, "xglClearDescriptorSets(descriptorRegion = %p, count = %i, pDescriptorSets = %p)", (void*)(pPacket->descriptorRegion), pPacket->count, (void*)(pPacket->pDescriptorSets));
-        return str;
-    }
-    case GLV_TPI_XGL_xglUpdateDescriptors:
-    {
-        struct_xglUpdateDescriptors* pPacket = (struct_xglUpdateDescriptors*)(pHeader->pBody);
-        snprintf(str, 1024, "xglUpdateDescriptors(descriptorSet = %p, pUpdateChain = %p)", (void*)(pPacket->descriptorSet), (void*)(pPacket->pUpdateChain));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDynamicViewportState:
-    {
-        struct_xglCreateDynamicViewportState* pPacket = (struct_xglCreateDynamicViewportState*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDynamicViewportState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDynamicRasterState:
-    {
-        struct_xglCreateDynamicRasterState* pPacket = (struct_xglCreateDynamicRasterState*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDynamicRasterState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
-    {
-        struct_xglCreateDynamicColorBlendState* pPacket = (struct_xglCreateDynamicColorBlendState*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDynamicColorBlendState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
-    {
-        struct_xglCreateDynamicDepthStencilState* pPacket = (struct_xglCreateDynamicDepthStencilState*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDynamicDepthStencilState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateCommandBuffer:
-    {
-        struct_xglCreateCommandBuffer* pPacket = (struct_xglCreateCommandBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateCommandBuffer(device = %p, pCreateInfo = %p, pCmdBuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pCmdBuffer);
-        return str;
-    }
-    case GLV_TPI_XGL_xglBeginCommandBuffer:
-    {
-        struct_xglBeginCommandBuffer* pPacket = (struct_xglBeginCommandBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBeginCommandBuffer(cmdBuffer = %p, pBeginInfo = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pBeginInfo));
-        return str;
-    }
-    case GLV_TPI_XGL_xglEndCommandBuffer:
-    {
-        struct_xglEndCommandBuffer* pPacket = (struct_xglEndCommandBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglEndCommandBuffer(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
-        return str;
-    }
-    case GLV_TPI_XGL_xglResetCommandBuffer:
-    {
-        struct_xglResetCommandBuffer* pPacket = (struct_xglResetCommandBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglResetCommandBuffer(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindPipeline:
-    {
-        struct_xglCmdBindPipeline* pPacket = (struct_xglCmdBindPipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindPipeline(cmdBuffer = %p, pipelineBindPoint = %p, pipeline = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->pipeline));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindPipelineDelta:
-    {
-        struct_xglCmdBindPipelineDelta* pPacket = (struct_xglCmdBindPipelineDelta*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindPipelineDelta(cmdBuffer = %p, pipelineBindPoint = %p, delta = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->delta));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
-    {
-        struct_xglCmdBindDynamicStateObject* pPacket = (struct_xglCmdBindDynamicStateObject*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindDynamicStateObject(cmdBuffer = %p, stateBindPoint = %p, state = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->stateBindPoint), (void*)(pPacket->state));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindDescriptorSet:
-    {
-        struct_xglCmdBindDescriptorSet* pPacket = (struct_xglCmdBindDescriptorSet*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindDescriptorSet(cmdBuffer = %p, pipelineBindPoint = %p, descriptorSet = %p, *pUserData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->descriptorSet), (pPacket->pUserData == NULL) ? 0 : *(pPacket->pUserData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindVertexBuffer:
-    {
-        struct_xglCmdBindVertexBuffer* pPacket = (struct_xglCmdBindVertexBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindVertexBuffer(cmdBuffer = %p, buffer = %p, offset = %p, binding = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->binding);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindIndexBuffer:
-    {
-        struct_xglCmdBindIndexBuffer* pPacket = (struct_xglCmdBindIndexBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindIndexBuffer(cmdBuffer = %p, buffer = %p, offset = %p, indexType = %s)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), string_XGL_INDEX_TYPE(pPacket->indexType));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDraw:
-    {
-        struct_xglCmdDraw* pPacket = (struct_xglCmdDraw*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDraw(cmdBuffer = %p, firstVertex = %i, vertexCount = %i, firstInstance = %i, instanceCount = %i)", (void*)(pPacket->cmdBuffer), pPacket->firstVertex, pPacket->vertexCount, pPacket->firstInstance, pPacket->instanceCount);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDrawIndexed:
-    {
-        struct_xglCmdDrawIndexed* pPacket = (struct_xglCmdDrawIndexed*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDrawIndexed(cmdBuffer = %p, firstIndex = %i, indexCount = %i, vertexOffset = %i, firstInstance = %i, instanceCount = %i)", (void*)(pPacket->cmdBuffer), pPacket->firstIndex, pPacket->indexCount, pPacket->vertexOffset, pPacket->firstInstance, pPacket->instanceCount);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDrawIndirect:
-    {
-        struct_xglCmdDrawIndirect* pPacket = (struct_xglCmdDrawIndirect*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDrawIndirect(cmdBuffer = %p, buffer = %p, offset = %p, count = %i, stride = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->count, pPacket->stride);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
-    {
-        struct_xglCmdDrawIndexedIndirect* pPacket = (struct_xglCmdDrawIndexedIndirect*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDrawIndexedIndirect(cmdBuffer = %p, buffer = %p, offset = %p, count = %i, stride = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->count, pPacket->stride);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDispatch:
-    {
-        struct_xglCmdDispatch* pPacket = (struct_xglCmdDispatch*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDispatch(cmdBuffer = %p, x = %i, y = %i, z = %i)", (void*)(pPacket->cmdBuffer), pPacket->x, pPacket->y, pPacket->z);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDispatchIndirect:
-    {
-        struct_xglCmdDispatchIndirect* pPacket = (struct_xglCmdDispatchIndirect*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDispatchIndirect(cmdBuffer = %p, buffer = %p, offset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCopyBuffer:
-    {
-        struct_xglCmdCopyBuffer* pPacket = (struct_xglCmdCopyBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCopyBuffer(cmdBuffer = %p, srcBuffer = %p, destBuffer = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcBuffer), (void*)(pPacket->destBuffer), pPacket->regionCount, (void*)(pPacket->pRegions));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCopyImage:
-    {
-        struct_xglCmdCopyImage* pPacket = (struct_xglCmdCopyImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCopyImage(cmdBuffer = %p, srcImage = %p, destImage = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destImage), pPacket->regionCount, (void*)(pPacket->pRegions));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCopyBufferToImage:
-    {
-        struct_xglCmdCopyBufferToImage* pPacket = (struct_xglCmdCopyBufferToImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCopyBufferToImage(cmdBuffer = %p, srcBuffer = %p, destImage = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcBuffer), (void*)(pPacket->destImage), pPacket->regionCount, (void*)(pPacket->pRegions));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
-    {
-        struct_xglCmdCopyImageToBuffer* pPacket = (struct_xglCmdCopyImageToBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCopyImageToBuffer(cmdBuffer = %p, srcImage = %p, destBuffer = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destBuffer), pPacket->regionCount, (void*)(pPacket->pRegions));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCloneImageData:
-    {
-        struct_xglCmdCloneImageData* pPacket = (struct_xglCmdCloneImageData*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCloneImageData(cmdBuffer = %p, srcImage = %p, srcImageLayout = %p, destImage = %p, destImageLayout = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->srcImageLayout), (void*)(pPacket->destImage), (void*)(pPacket->destImageLayout));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdUpdateBuffer:
-    {
-        struct_xglCmdUpdateBuffer* pPacket = (struct_xglCmdUpdateBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdUpdateBuffer(cmdBuffer = %p, destBuffer = %p, destOffset = %p, dataSize = %p, *pData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset), (void*)(pPacket->dataSize), (pPacket->pData == NULL) ? 0 : *(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdFillBuffer:
-    {
-        struct_xglCmdFillBuffer* pPacket = (struct_xglCmdFillBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdFillBuffer(cmdBuffer = %p, destBuffer = %p, destOffset = %p, fillSize = %p, data = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset), (void*)(pPacket->fillSize), pPacket->data);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdClearColorImage:
-    {
-        struct_xglCmdClearColorImage* pPacket = (struct_xglCmdClearColorImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdClearColorImage(cmdBuffer = %p, image = %p, color = [%f, %f, %f, %f], rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3], pPacket->rangeCount, (void*)(pPacket->pRanges));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdClearColorImageRaw:
-    {
-        struct_xglCmdClearColorImageRaw* pPacket = (struct_xglCmdClearColorImageRaw*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdClearColorImageRaw(cmdBuffer = %p, image = %p, color = [%i, %i, %i, %i], rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3], pPacket->rangeCount, (void*)(pPacket->pRanges));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdClearDepthStencil:
-    {
-        struct_xglCmdClearDepthStencil* pPacket = (struct_xglCmdClearDepthStencil*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdClearDepthStencil(cmdBuffer = %p, image = %p, depth = %f, stencil = %i, rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->depth, pPacket->stencil, pPacket->rangeCount, (void*)(pPacket->pRanges));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdResolveImage:
-    {
-        struct_xglCmdResolveImage* pPacket = (struct_xglCmdResolveImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdResolveImage(cmdBuffer = %p, srcImage = %p, destImage = %p, rectCount = %i, pRects = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destImage), pPacket->rectCount, (void*)(pPacket->pRects));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdSetEvent:
-    {
-        struct_xglCmdSetEvent* pPacket = (struct_xglCmdSetEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdSetEvent(cmdBuffer = %p, event = %p, pipeEvent = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->event), (void*)(pPacket->pipeEvent));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdResetEvent:
-    {
-        struct_xglCmdResetEvent* pPacket = (struct_xglCmdResetEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdResetEvent(cmdBuffer = %p, event = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->event));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdWaitEvents:
-    {
-        struct_xglCmdWaitEvents* pPacket = (struct_xglCmdWaitEvents*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdWaitEvents(cmdBuffer = %p, pWaitInfo = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pWaitInfo));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdPipelineBarrier:
-    {
-        struct_xglCmdPipelineBarrier* pPacket = (struct_xglCmdPipelineBarrier*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdPipelineBarrier(cmdBuffer = %p, pBarrier = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pBarrier));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBeginQuery:
-    {
-        struct_xglCmdBeginQuery* pPacket = (struct_xglCmdBeginQuery*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBeginQuery(cmdBuffer = %p, queryPool = %p, slot = %i, flags = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->slot, pPacket->flags);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdEndQuery:
-    {
-        struct_xglCmdEndQuery* pPacket = (struct_xglCmdEndQuery*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdEndQuery(cmdBuffer = %p, queryPool = %p, slot = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->slot);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdResetQueryPool:
-    {
-        struct_xglCmdResetQueryPool* pPacket = (struct_xglCmdResetQueryPool*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdResetQueryPool(cmdBuffer = %p, queryPool = %p, startQuery = %i, queryCount = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdWriteTimestamp:
-    {
-        struct_xglCmdWriteTimestamp* pPacket = (struct_xglCmdWriteTimestamp*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdWriteTimestamp(cmdBuffer = %p, timestampType = %s, destBuffer = %p, destOffset = %p)", (void*)(pPacket->cmdBuffer), string_XGL_TIMESTAMP_TYPE(pPacket->timestampType), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdInitAtomicCounters:
-    {
-        struct_xglCmdInitAtomicCounters* pPacket = (struct_xglCmdInitAtomicCounters*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdInitAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, *pData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (pPacket->pData == NULL) ? 0 : *(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
-    {
-        struct_xglCmdLoadAtomicCounters* pPacket = (struct_xglCmdLoadAtomicCounters*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdLoadAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, srcBuffer = %p, srcOffset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (void*)(pPacket->srcBuffer), (void*)(pPacket->srcOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
-    {
-        struct_xglCmdSaveAtomicCounters* pPacket = (struct_xglCmdSaveAtomicCounters*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdSaveAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, destBuffer = %p, destOffset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateFramebuffer:
-    {
-        struct_xglCreateFramebuffer* pPacket = (struct_xglCreateFramebuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateFramebuffer(device = %p, pCreateInfo = %p, pFramebuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pFramebuffer);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateRenderPass:
-    {
-        struct_xglCreateRenderPass* pPacket = (struct_xglCreateRenderPass*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateRenderPass(device = %p, pCreateInfo = %p, pRenderPass = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pRenderPass);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBeginRenderPass:
-    {
-        struct_xglCmdBeginRenderPass* pPacket = (struct_xglCmdBeginRenderPass*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBeginRenderPass(cmdBuffer = %p, renderPass = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->renderPass));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdEndRenderPass:
-    {
-        struct_xglCmdEndRenderPass* pPacket = (struct_xglCmdEndRenderPass*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdEndRenderPass(cmdBuffer = %p, renderPass = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->renderPass));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetValidationLevel:
-    {
-        struct_xglDbgSetValidationLevel* pPacket = (struct_xglDbgSetValidationLevel*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetValidationLevel(device = %p, validationLevel = %p)", (void*)(pPacket->device), (void*)(pPacket->validationLevel));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
-    {
-        struct_xglDbgRegisterMsgCallback* pPacket = (struct_xglDbgRegisterMsgCallback*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgRegisterMsgCallback(pfnMsgCallback = %p, pUserData = %p)", (void*)(pPacket->pfnMsgCallback), (void*)(pPacket->pUserData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
-    {
-        struct_xglDbgUnregisterMsgCallback* pPacket = (struct_xglDbgUnregisterMsgCallback*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgUnregisterMsgCallback(pfnMsgCallback = %p)", (void*)(pPacket->pfnMsgCallback));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetMessageFilter:
-    {
-        struct_xglDbgSetMessageFilter* pPacket = (struct_xglDbgSetMessageFilter*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetMessageFilter(device = %p, msgCode = %i, filter = %p)", (void*)(pPacket->device), pPacket->msgCode, (void*)(pPacket->filter));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetObjectTag:
-    {
-        struct_xglDbgSetObjectTag* pPacket = (struct_xglDbgSetObjectTag*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetObjectTag(object = %p, tagSize = %zu, pTag = %p)", (void*)(pPacket->object), pPacket->tagSize, (void*)(pPacket->pTag));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetGlobalOption:
-    {
-        struct_xglDbgSetGlobalOption* pPacket = (struct_xglDbgSetGlobalOption*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetGlobalOption(dbgOption = %p, dataSize = %zu, pData = %p)", (void*)(pPacket->dbgOption), pPacket->dataSize, (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetDeviceOption:
-    {
-        struct_xglDbgSetDeviceOption* pPacket = (struct_xglDbgSetDeviceOption*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetDeviceOption(device = %p, dbgOption = %p, dataSize = %zu, pData = %p)", (void*)(pPacket->device), (void*)(pPacket->dbgOption), pPacket->dataSize, (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
-    {
-        struct_xglCmdDbgMarkerBegin* pPacket = (struct_xglCmdDbgMarkerBegin*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDbgMarkerBegin(cmdBuffer = %p, pMarker = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pMarker));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
-    {
-        struct_xglCmdDbgMarkerEnd* pPacket = (struct_xglCmdDbgMarkerEnd*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDbgMarkerEnd(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWsiX11AssociateConnection:
-    {
-        struct_xglWsiX11AssociateConnection* pPacket = (struct_xglWsiX11AssociateConnection*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWsiX11AssociateConnection(gpu = %p, pConnectionInfo = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pConnectionInfo));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWsiX11GetMSC:
-    {
-        struct_xglWsiX11GetMSC* pPacket = (struct_xglWsiX11GetMSC*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWsiX11GetMSC(device = %p, window = %i, crtc = %u, *pMsc = %lu)", (void*)(pPacket->device), pPacket->window, pPacket->crtc, (pPacket->pMsc == NULL) ? 0 : *(pPacket->pMsc));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
-    {
-        struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWsiX11CreatePresentableImage(device = %p, pCreateInfo = %p, pImage = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)(pPacket->pImage), (void*)pPacket->pMem);
-        return str;
-    }
-    case GLV_TPI_XGL_xglWsiX11QueuePresent:
-    {
-        struct_xglWsiX11QueuePresent* pPacket = (struct_xglWsiX11QueuePresent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWsiX11QueuePresent(queue = %p, pPresentInfo = %p, fence = %p)", (void*)(pPacket->queue), (void*)(pPacket->pPresentInfo), (void*)(pPacket->fence));
-        return str;
-    }
-    default:
-        return NULL;
-    }
-};
-
-static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)
-{
-    if (pHeader == NULL)
-    {
-        return NULL;
-    }
-    switch (pHeader->packet_id)
-    {
-        case GLV_TPI_XGL_xglApiVersion:
-        {
-            return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;
-        }
-        case GLV_TPI_XGL_xglCreateInstance:
-        {
-            return interpret_body_as_xglCreateInstance(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDestroyInstance:
-        {
-            return interpret_body_as_xglDestroyInstance(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglEnumerateGpus:
-        {
-            return interpret_body_as_xglEnumerateGpus(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetGpuInfo:
-        {
-            return interpret_body_as_xglGetGpuInfo(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetProcAddr:
-        {
-            return interpret_body_as_xglGetProcAddr(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDevice:
-        {
-            return interpret_body_as_xglCreateDevice(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDestroyDevice:
-        {
-            return interpret_body_as_xglDestroyDevice(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetExtensionSupport:
-        {
-            return interpret_body_as_xglGetExtensionSupport(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglEnumerateLayers:
-        {
-            return interpret_body_as_xglEnumerateLayers(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetDeviceQueue:
-        {
-            return interpret_body_as_xglGetDeviceQueue(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglQueueSubmit:
-        {
-            return interpret_body_as_xglQueueSubmit(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
-        {
-            return interpret_body_as_xglQueueSetGlobalMemReferences(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglQueueWaitIdle:
-        {
-            return interpret_body_as_xglQueueWaitIdle(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDeviceWaitIdle:
-        {
-            return interpret_body_as_xglDeviceWaitIdle(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglAllocMemory:
-        {
-            return interpret_body_as_xglAllocMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglFreeMemory:
-        {
-            return interpret_body_as_xglFreeMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSetMemoryPriority:
-        {
-            return interpret_body_as_xglSetMemoryPriority(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglMapMemory:
-        {
-            return interpret_body_as_xglMapMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglUnmapMemory:
-        {
-            return interpret_body_as_xglUnmapMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglPinSystemMemory:
-        {
-            return interpret_body_as_xglPinSystemMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
-        {
-            return interpret_body_as_xglGetMultiGpuCompatibility(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglOpenSharedMemory:
-        {
-            return interpret_body_as_xglOpenSharedMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
-        {
-            return interpret_body_as_xglOpenSharedQueueSemaphore(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglOpenPeerMemory:
-        {
-            return interpret_body_as_xglOpenPeerMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglOpenPeerImage:
-        {
-            return interpret_body_as_xglOpenPeerImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDestroyObject:
-        {
-            return interpret_body_as_xglDestroyObject(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetObjectInfo:
-        {
-            return interpret_body_as_xglGetObjectInfo(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBindObjectMemory:
-        {
-            return interpret_body_as_xglBindObjectMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBindObjectMemoryRange:
-        {
-            return interpret_body_as_xglBindObjectMemoryRange(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBindImageMemoryRange:
-        {
-            return interpret_body_as_xglBindImageMemoryRange(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateFence:
-        {
-            return interpret_body_as_xglCreateFence(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetFenceStatus:
-        {
-            return interpret_body_as_xglGetFenceStatus(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglWaitForFences:
-        {
-            return interpret_body_as_xglWaitForFences(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateQueueSemaphore:
-        {
-            return interpret_body_as_xglCreateQueueSemaphore(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSignalQueueSemaphore:
-        {
-            return interpret_body_as_xglSignalQueueSemaphore(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglWaitQueueSemaphore:
-        {
-            return interpret_body_as_xglWaitQueueSemaphore(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateEvent:
-        {
-            return interpret_body_as_xglCreateEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetEventStatus:
-        {
-            return interpret_body_as_xglGetEventStatus(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSetEvent:
-        {
-            return interpret_body_as_xglSetEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglResetEvent:
-        {
-            return interpret_body_as_xglResetEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateQueryPool:
-        {
-            return interpret_body_as_xglCreateQueryPool(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetQueryPoolResults:
-        {
-            return interpret_body_as_xglGetQueryPoolResults(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetFormatInfo:
-        {
-            return interpret_body_as_xglGetFormatInfo(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateBuffer:
-        {
-            return interpret_body_as_xglCreateBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateBufferView:
-        {
-            return interpret_body_as_xglCreateBufferView(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateImage:
-        {
-            return interpret_body_as_xglCreateImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSetFastClearColor:
-        {
-            return interpret_body_as_xglSetFastClearColor(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSetFastClearDepth:
-        {
-            return interpret_body_as_xglSetFastClearDepth(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetImageSubresourceInfo:
-        {
-            return interpret_body_as_xglGetImageSubresourceInfo(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateImageView:
-        {
-            return interpret_body_as_xglCreateImageView(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateColorAttachmentView:
-        {
-            return interpret_body_as_xglCreateColorAttachmentView(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDepthStencilView:
-        {
-            return interpret_body_as_xglCreateDepthStencilView(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateShader:
-        {
-            return interpret_body_as_xglCreateShader(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateGraphicsPipeline:
-        {
-            return interpret_body_as_xglCreateGraphicsPipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateComputePipeline:
-        {
-            return interpret_body_as_xglCreateComputePipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglStorePipeline:
-        {
-            return interpret_body_as_xglStorePipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglLoadPipeline:
-        {
-            return interpret_body_as_xglLoadPipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreatePipelineDelta:
-        {
-            return interpret_body_as_xglCreatePipelineDelta(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateSampler:
-        {
-            return interpret_body_as_xglCreateSampler(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
-        {
-            return interpret_body_as_xglCreateDescriptorSetLayout(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
-        {
-            return interpret_body_as_xglBeginDescriptorRegionUpdate(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
-        {
-            return interpret_body_as_xglEndDescriptorRegionUpdate(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDescriptorRegion:
-        {
-            return interpret_body_as_xglCreateDescriptorRegion(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglClearDescriptorRegion:
-        {
-            return interpret_body_as_xglClearDescriptorRegion(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglAllocDescriptorSets:
-        {
-            return interpret_body_as_xglAllocDescriptorSets(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglClearDescriptorSets:
-        {
-            return interpret_body_as_xglClearDescriptorSets(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglUpdateDescriptors:
-        {
-            return interpret_body_as_xglUpdateDescriptors(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDynamicViewportState:
-        {
-            return interpret_body_as_xglCreateDynamicViewportState(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDynamicRasterState:
-        {
-            return interpret_body_as_xglCreateDynamicRasterState(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
-        {
-            return interpret_body_as_xglCreateDynamicColorBlendState(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
-        {
-            return interpret_body_as_xglCreateDynamicDepthStencilState(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateCommandBuffer:
-        {
-            return interpret_body_as_xglCreateCommandBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBeginCommandBuffer:
-        {
-            return interpret_body_as_xglBeginCommandBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglEndCommandBuffer:
-        {
-            return interpret_body_as_xglEndCommandBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglResetCommandBuffer:
-        {
-            return interpret_body_as_xglResetCommandBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindPipeline:
-        {
-            return interpret_body_as_xglCmdBindPipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindPipelineDelta:
-        {
-            return interpret_body_as_xglCmdBindPipelineDelta(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
-        {
-            return interpret_body_as_xglCmdBindDynamicStateObject(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindDescriptorSet:
-        {
-            return interpret_body_as_xglCmdBindDescriptorSet(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindVertexBuffer:
-        {
-            return interpret_body_as_xglCmdBindVertexBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindIndexBuffer:
-        {
-            return interpret_body_as_xglCmdBindIndexBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDraw:
-        {
-            return interpret_body_as_xglCmdDraw(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDrawIndexed:
-        {
-            return interpret_body_as_xglCmdDrawIndexed(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDrawIndirect:
-        {
-            return interpret_body_as_xglCmdDrawIndirect(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
-        {
-            return interpret_body_as_xglCmdDrawIndexedIndirect(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDispatch:
-        {
-            return interpret_body_as_xglCmdDispatch(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDispatchIndirect:
-        {
-            return interpret_body_as_xglCmdDispatchIndirect(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCopyBuffer:
-        {
-            return interpret_body_as_xglCmdCopyBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCopyImage:
-        {
-            return interpret_body_as_xglCmdCopyImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCopyBufferToImage:
-        {
-            return interpret_body_as_xglCmdCopyBufferToImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
-        {
-            return interpret_body_as_xglCmdCopyImageToBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCloneImageData:
-        {
-            return interpret_body_as_xglCmdCloneImageData(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdUpdateBuffer:
-        {
-            return interpret_body_as_xglCmdUpdateBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdFillBuffer:
-        {
-            return interpret_body_as_xglCmdFillBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdClearColorImage:
-        {
-            return interpret_body_as_xglCmdClearColorImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdClearColorImageRaw:
-        {
-            return interpret_body_as_xglCmdClearColorImageRaw(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdClearDepthStencil:
-        {
-            return interpret_body_as_xglCmdClearDepthStencil(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdResolveImage:
-        {
-            return interpret_body_as_xglCmdResolveImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdSetEvent:
-        {
-            return interpret_body_as_xglCmdSetEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdResetEvent:
-        {
-            return interpret_body_as_xglCmdResetEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdWaitEvents:
-        {
-            return interpret_body_as_xglCmdWaitEvents(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdPipelineBarrier:
-        {
-            return interpret_body_as_xglCmdPipelineBarrier(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBeginQuery:
-        {
-            return interpret_body_as_xglCmdBeginQuery(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdEndQuery:
-        {
-            return interpret_body_as_xglCmdEndQuery(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdResetQueryPool:
-        {
-            return interpret_body_as_xglCmdResetQueryPool(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdWriteTimestamp:
-        {
-            return interpret_body_as_xglCmdWriteTimestamp(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdInitAtomicCounters:
-        {
-            return interpret_body_as_xglCmdInitAtomicCounters(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
-        {
-            return interpret_body_as_xglCmdLoadAtomicCounters(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
-        {
-            return interpret_body_as_xglCmdSaveAtomicCounters(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateFramebuffer:
-        {
-            return interpret_body_as_xglCreateFramebuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateRenderPass:
-        {
-            return interpret_body_as_xglCreateRenderPass(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBeginRenderPass:
-        {
-            return interpret_body_as_xglCmdBeginRenderPass(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdEndRenderPass:
-        {
-            return interpret_body_as_xglCmdEndRenderPass(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDbgSetValidationLevel:
-        {
-            return interpret_body_as_xglDbgSetValidationLevel(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
-        {
-            return interpret_body_as_xglDbgRegisterMsgCallback(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
-        {
-            return interpret_body_as_xglDbgUnregisterMsgCallback(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgSetMessageFilter:
-        {
-            return interpret_body_as_xglDbgSetMessageFilter(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgSetObjectTag:
-        {
-            return interpret_body_as_xglDbgSetObjectTag(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgSetGlobalOption:
-        {
-            return interpret_body_as_xglDbgSetGlobalOption(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgSetDeviceOption:
-        {
-            return interpret_body_as_xglDbgSetDeviceOption(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
-        {
-            return interpret_body_as_xglCmdDbgMarkerBegin(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
-        {
-            return interpret_body_as_xglCmdDbgMarkerEnd(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglWsiX11AssociateConnection:
-        {
-            return interpret_body_as_xglWsiX11AssociateConnection(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglWsiX11GetMSC:
-        {
-            return interpret_body_as_xglWsiX11GetMSC(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
-        {
-            return interpret_body_as_xglWsiX11CreatePresentableImage(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglWsiX11QueuePresent:
-        {
-            return interpret_body_as_xglWsiX11QueuePresent(pHeader)->pHeader;
-        }
-        default:
-            return NULL;
-    }
-    return NULL;
-}
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h
index 0c581ef..d68bb20 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h
@@ -3,70 +3,16 @@
 #include <xgl.h>
 
 
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+    switch ((XGL_DEPTH_MODE)input_value)
     {
-        case XGL_TOPOLOGY_LINE_LIST:
-            return "XGL_TOPOLOGY_LINE_LIST";
-        case XGL_TOPOLOGY_LINE_LIST_ADJ:
-            return "XGL_TOPOLOGY_LINE_LIST_ADJ";
-        case XGL_TOPOLOGY_LINE_STRIP:
-            return "XGL_TOPOLOGY_LINE_STRIP";
-        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
-            return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
-        case XGL_TOPOLOGY_PATCH:
-            return "XGL_TOPOLOGY_PATCH";
-        case XGL_TOPOLOGY_POINT_LIST:
-            return "XGL_TOPOLOGY_POINT_LIST";
-        case XGL_TOPOLOGY_QUAD_LIST:
-            return "XGL_TOPOLOGY_QUAD_LIST";
-        case XGL_TOPOLOGY_QUAD_STRIP:
-            return "XGL_TOPOLOGY_QUAD_STRIP";
-        case XGL_TOPOLOGY_RECT_LIST:
-            return "XGL_TOPOLOGY_RECT_LIST";
-        case XGL_TOPOLOGY_TRIANGLE_LIST:
-            return "XGL_TOPOLOGY_TRIANGLE_LIST";
-        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
-            return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
-        case XGL_TOPOLOGY_TRIANGLE_STRIP:
-            return "XGL_TOPOLOGY_TRIANGLE_STRIP";
-        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
-            return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+            return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+        case XGL_DEPTH_MODE_ZERO_TO_ONE:
+            return "XGL_DEPTH_MODE_ZERO_TO_ONE";
         default:
-            return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
-    }
-}
-
-
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
-    switch ((XGL_BLEND_FUNC)input_value)
-    {
-        case XGL_BLEND_FUNC_ADD:
-            return "XGL_BLEND_FUNC_ADD";
-        case XGL_BLEND_FUNC_MAX:
-            return "XGL_BLEND_FUNC_MAX";
-        case XGL_BLEND_FUNC_MIN:
-            return "XGL_BLEND_FUNC_MIN";
-        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
-            return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
-        case XGL_BLEND_FUNC_SUBTRACT:
-            return "XGL_BLEND_FUNC_SUBTRACT";
-        default:
-            return "Unhandled XGL_BLEND_FUNC";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
-    {
-        case XGL_MEMORY_REF_READ_ONLY_BIT:
-            return "XGL_MEMORY_REF_READ_ONLY_BIT";
-        default:
-            return "Unhandled XGL_MEMORY_REF_FLAGS";
+            return "Unhandled XGL_DEPTH_MODE";
     }
 }
 
@@ -89,180 +35,40 @@
 }
 
 
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_PIPELINE_BIND_POINT)input_value)
     {
-        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
-            return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
-        case XGL_MEMORY_OUTPUT_COPY_BIT:
-            return "XGL_MEMORY_OUTPUT_COPY_BIT";
-        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
-            return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
-        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-            return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
-        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
-            return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+        case XGL_PIPELINE_BIND_POINT_COMPUTE:
+            return "XGL_PIPELINE_BIND_POINT_COMPUTE";
+        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+            return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
         default:
-            return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+            return "Unhandled XGL_PIPELINE_BIND_POINT";
     }
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    switch ((XGL_MEMORY_REF_FLAGS)input_value)
     {
-        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
-            return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
-        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
-            return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+        case XGL_MEMORY_REF_READ_ONLY_BIT:
+            return "XGL_MEMORY_REF_READ_ONLY_BIT";
         default:
-            return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+            return "Unhandled XGL_MEMORY_REF_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_STATE_BIND_POINT)input_value)
+    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
     {
-        case XGL_STATE_BIND_COLOR_BLEND:
-            return "XGL_STATE_BIND_COLOR_BLEND";
-        case XGL_STATE_BIND_DEPTH_STENCIL:
-            return "XGL_STATE_BIND_DEPTH_STENCIL";
-        case XGL_STATE_BIND_RASTER:
-            return "XGL_STATE_BIND_RASTER";
-        case XGL_STATE_BIND_VIEWPORT:
-            return "XGL_STATE_BIND_VIEWPORT";
+        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
         default:
-            return "Unhandled XGL_STATE_BIND_POINT";
-    }
-}
-
-
-static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
-{
-    switch ((XGL_LOGIC_OP)input_value)
-    {
-        case XGL_LOGIC_OP_AND:
-            return "XGL_LOGIC_OP_AND";
-        case XGL_LOGIC_OP_AND_INVERTED:
-            return "XGL_LOGIC_OP_AND_INVERTED";
-        case XGL_LOGIC_OP_AND_REVERSE:
-            return "XGL_LOGIC_OP_AND_REVERSE";
-        case XGL_LOGIC_OP_CLEAR:
-            return "XGL_LOGIC_OP_CLEAR";
-        case XGL_LOGIC_OP_COPY:
-            return "XGL_LOGIC_OP_COPY";
-        case XGL_LOGIC_OP_COPY_INVERTED:
-            return "XGL_LOGIC_OP_COPY_INVERTED";
-        case XGL_LOGIC_OP_EQUIV:
-            return "XGL_LOGIC_OP_EQUIV";
-        case XGL_LOGIC_OP_INVERT:
-            return "XGL_LOGIC_OP_INVERT";
-        case XGL_LOGIC_OP_NAND:
-            return "XGL_LOGIC_OP_NAND";
-        case XGL_LOGIC_OP_NOOP:
-            return "XGL_LOGIC_OP_NOOP";
-        case XGL_LOGIC_OP_NOR:
-            return "XGL_LOGIC_OP_NOR";
-        case XGL_LOGIC_OP_OR:
-            return "XGL_LOGIC_OP_OR";
-        case XGL_LOGIC_OP_OR_INVERTED:
-            return "XGL_LOGIC_OP_OR_INVERTED";
-        case XGL_LOGIC_OP_OR_REVERSE:
-            return "XGL_LOGIC_OP_OR_REVERSE";
-        case XGL_LOGIC_OP_SET:
-            return "XGL_LOGIC_OP_SET";
-        case XGL_LOGIC_OP_XOR:
-            return "XGL_LOGIC_OP_XOR";
-        default:
-            return "Unhandled XGL_LOGIC_OP";
-    }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
-    {
-        case XGL_DESCRIPTOR_TYPE_IMAGE:
-            return "XGL_DESCRIPTOR_TYPE_IMAGE";
-        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
-        case XGL_DESCRIPTOR_TYPE_SAMPLER:
-            return "XGL_DESCRIPTOR_TYPE_SAMPLER";
-        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
-            return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
-        case XGL_DESCRIPTOR_TYPE_TEXTURE:
-            return "XGL_DESCRIPTOR_TYPE_TEXTURE";
-        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
-        default:
-            return "Unhandled XGL_DESCRIPTOR_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
-        default:
-            return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
-{
-    switch ((XGL_MEMORY_TYPE)input_value)
-    {
-        case XGL_MEMORY_TYPE_BUFFER:
-            return "XGL_MEMORY_TYPE_BUFFER";
-        case XGL_MEMORY_TYPE_IMAGE:
-            return "XGL_MEMORY_TYPE_IMAGE";
-        case XGL_MEMORY_TYPE_OTHER:
-            return "XGL_MEMORY_TYPE_OTHER";
-        default:
-            return "Unhandled XGL_MEMORY_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
-    switch ((XGL_MEMORY_PRIORITY)input_value)
-    {
-        case XGL_MEMORY_PRIORITY_HIGH:
-            return "XGL_MEMORY_PRIORITY_HIGH";
-        case XGL_MEMORY_PRIORITY_LOW:
-            return "XGL_MEMORY_PRIORITY_LOW";
-        case XGL_MEMORY_PRIORITY_NORMAL:
-            return "XGL_MEMORY_PRIORITY_NORMAL";
-        case XGL_MEMORY_PRIORITY_UNUSED:
-            return "XGL_MEMORY_PRIORITY_UNUSED";
-        case XGL_MEMORY_PRIORITY_VERY_HIGH:
-            return "XGL_MEMORY_PRIORITY_VERY_HIGH";
-        case XGL_MEMORY_PRIORITY_VERY_LOW:
-            return "XGL_MEMORY_PRIORITY_VERY_LOW";
-        default:
-            return "Unhandled XGL_MEMORY_PRIORITY";
+            return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
     }
 }
 
@@ -283,16 +89,16 @@
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 {
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    switch ((XGL_QUERY_TYPE)input_value)
     {
-        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
-            return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
-        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
-            return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+        case XGL_QUERY_OCCLUSION:
+            return "XGL_QUERY_OCCLUSION";
+        case XGL_QUERY_PIPELINE_STATISTICS:
+            return "XGL_QUERY_PIPELINE_STATISTICS";
         default:
-            return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+            return "Unhandled XGL_QUERY_TYPE";
     }
 }
 
@@ -313,52 +119,30 @@
 }
 
 
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
 {
-    switch ((XGL_QUEUE_TYPE)input_value)
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
     {
-        case XGL_QUEUE_TYPE_COMPUTE:
-            return "XGL_QUEUE_TYPE_COMPUTE";
-        case XGL_QUEUE_TYPE_DMA:
-            return "XGL_QUEUE_TYPE_DMA";
-        case XGL_QUEUE_TYPE_GRAPHICS:
-            return "XGL_QUEUE_TYPE_GRAPHICS";
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+            return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+            return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
         default:
-            return "Unhandled XGL_QUEUE_TYPE";
+            return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
     {
-        case XGL_SYSTEM_ALLOC_API_OBJECT:
-            return "XGL_SYSTEM_ALLOC_API_OBJECT";
-        case XGL_SYSTEM_ALLOC_DEBUG:
-            return "XGL_SYSTEM_ALLOC_DEBUG";
-        case XGL_SYSTEM_ALLOC_INTERNAL:
-            return "XGL_SYSTEM_ALLOC_INTERNAL";
-        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
-            return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
-        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
-            return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
+        case XGL_TIMESTAMP_BOTTOM:
+            return "XGL_TIMESTAMP_BOTTOM";
+        case XGL_TIMESTAMP_TOP:
+            return "XGL_TIMESTAMP_TOP";
         default:
-            return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
-    switch ((XGL_DEPTH_MODE)input_value)
-    {
-        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
-            return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
-        case XGL_DEPTH_MODE_ZERO_TO_ONE:
-            return "XGL_DEPTH_MODE_ZERO_TO_ONE";
-        default:
-            return "Unhandled XGL_DEPTH_MODE";
+            return "Unhandled XGL_TIMESTAMP_TYPE";
     }
 }
 
@@ -377,176 +161,100 @@
 }
 
 
-static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 {
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+    switch ((XGL_IMAGE_ASPECT)input_value)
     {
-        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
-            return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
-        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
-            return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
-        case XGL_IMAGE_USAGE_GENERAL:
-            return "XGL_IMAGE_USAGE_GENERAL";
-        case XGL_IMAGE_USAGE_IMAGE_BIT:
-            return "XGL_IMAGE_USAGE_IMAGE_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
-        case XGL_IMAGE_USAGE_TEXTURE_BIT:
-            return "XGL_IMAGE_USAGE_TEXTURE_BIT";
-        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
-            return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
-        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
-            return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
+        case XGL_IMAGE_ASPECT_COLOR:
+            return "XGL_IMAGE_ASPECT_COLOR";
+        case XGL_IMAGE_ASPECT_DEPTH:
+            return "XGL_IMAGE_ASPECT_DEPTH";
+        case XGL_IMAGE_ASPECT_STENCIL:
+            return "XGL_IMAGE_ASPECT_STENCIL";
         default:
-            return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+            return "Unhandled XGL_IMAGE_ASPECT";
     }
 }
 
 
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
     {
-        case XGL_GPU_TYPE_DISCRETE:
-            return "XGL_GPU_TYPE_DISCRETE";
-        case XGL_GPU_TYPE_INTEGRATED:
-            return "XGL_GPU_TYPE_INTEGRATED";
-        case XGL_GPU_TYPE_OTHER:
-            return "XGL_GPU_TYPE_OTHER";
-        case XGL_GPU_TYPE_VIRTUAL:
-            return "XGL_GPU_TYPE_VIRTUAL";
+        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+            return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+            return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
         default:
-            return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+            return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
     }
 }
 
 
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_STENCIL_OP)input_value)
+    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
     {
-        case XGL_STENCIL_OP_DEC_CLAMP:
-            return "XGL_STENCIL_OP_DEC_CLAMP";
-        case XGL_STENCIL_OP_DEC_WRAP:
-            return "XGL_STENCIL_OP_DEC_WRAP";
-        case XGL_STENCIL_OP_INC_CLAMP:
-            return "XGL_STENCIL_OP_INC_CLAMP";
-        case XGL_STENCIL_OP_INC_WRAP:
-            return "XGL_STENCIL_OP_INC_WRAP";
-        case XGL_STENCIL_OP_INVERT:
-            return "XGL_STENCIL_OP_INVERT";
-        case XGL_STENCIL_OP_KEEP:
-            return "XGL_STENCIL_OP_KEEP";
-        case XGL_STENCIL_OP_REPLACE:
-            return "XGL_STENCIL_OP_REPLACE";
-        case XGL_STENCIL_OP_ZERO:
-            return "XGL_STENCIL_OP_ZERO";
+        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
         default:
-            return "Unhandled XGL_STENCIL_OP";
+            return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
 {
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
     {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-            return "XGL_BORDER_COLOR_OPAQUE_BLACK";
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-            return "XGL_BORDER_COLOR_OPAQUE_WHITE";
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
-            return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
         default:
-            return "Unhandled XGL_BORDER_COLOR_TYPE";
+            return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
 {
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
     {
-        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
-            return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
-        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
-            return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
-        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
-            return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
-        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
-        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
-        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
-        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
-            return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+        case XGL_BUFFER_USAGE_GENERAL:
+            return "XGL_BUFFER_USAGE_GENERAL";
+        case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
+            return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
+        case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
+            return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
+        case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
+            return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
+        case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
+            return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+            return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
+            return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
+            return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
+        case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
+            return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
+        case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
+            return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
+        case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
+            return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
+        case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
+            return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
+        case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
+            return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
+        case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
+            return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
         default:
-            return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
-    {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
-        default:
-            return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
-    {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-            return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
-            return "XGL_DEVICE_CREATE_VALIDATION_BIT";
-        default:
-            return "Unhandled XGL_DEVICE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
-        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
-        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
-            return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
-        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
-        default:
-            return "Unhandled XGL_OBJECT_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
-    {
-        case XGL_TEX_MIPMAP_BASE:
-            return "XGL_TEX_MIPMAP_BASE";
-        case XGL_TEX_MIPMAP_LINEAR:
-            return "XGL_TEX_MIPMAP_LINEAR";
-        case XGL_TEX_MIPMAP_NEAREST:
-            return "XGL_TEX_MIPMAP_NEAREST";
-        default:
-            return "Unhandled XGL_TEX_MIPMAP_MODE";
+            return "Unhandled XGL_BUFFER_USAGE_FLAGS";
     }
 }
 
@@ -671,158 +379,20 @@
 }
 
 
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
+    switch ((XGL_STATE_BIND_POINT)input_value)
     {
-        case XGL_TIMESTAMP_BOTTOM:
-            return "XGL_TIMESTAMP_BOTTOM";
-        case XGL_TIMESTAMP_TOP:
-            return "XGL_TIMESTAMP_TOP";
+        case XGL_STATE_BIND_COLOR_BLEND:
+            return "XGL_STATE_BIND_COLOR_BLEND";
+        case XGL_STATE_BIND_DEPTH_STENCIL:
+            return "XGL_STATE_BIND_DEPTH_STENCIL";
+        case XGL_STATE_BIND_RASTER:
+            return "XGL_STATE_BIND_RASTER";
+        case XGL_STATE_BIND_VIEWPORT:
+            return "XGL_STATE_BIND_VIEWPORT";
         default:
-            return "Unhandled XGL_TIMESTAMP_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
-    {
-        case XGL_PROVOKING_VERTEX_FIRST:
-            return "XGL_PROVOKING_VERTEX_FIRST";
-        case XGL_PROVOKING_VERTEX_LAST:
-            return "XGL_PROVOKING_VERTEX_LAST";
-        default:
-            return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
-    }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
-        default:
-            return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
-{
-    switch ((XGL_TEX_FILTER)input_value)
-    {
-        case XGL_TEX_FILTER_LINEAR:
-            return "XGL_TEX_FILTER_LINEAR";
-        case XGL_TEX_FILTER_NEAREST:
-            return "XGL_TEX_FILTER_NEAREST";
-        default:
-            return "Unhandled XGL_TEX_FILTER";
-    }
-}
-
-
-static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
-{
-    switch ((XGL_BLEND)input_value)
-    {
-        case XGL_BLEND_CONSTANT_ALPHA:
-            return "XGL_BLEND_CONSTANT_ALPHA";
-        case XGL_BLEND_CONSTANT_COLOR:
-            return "XGL_BLEND_CONSTANT_COLOR";
-        case XGL_BLEND_DEST_ALPHA:
-            return "XGL_BLEND_DEST_ALPHA";
-        case XGL_BLEND_DEST_COLOR:
-            return "XGL_BLEND_DEST_COLOR";
-        case XGL_BLEND_ONE:
-            return "XGL_BLEND_ONE";
-        case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
-            return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
-        case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
-            return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
-        case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
-            return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
-        case XGL_BLEND_ONE_MINUS_DEST_COLOR:
-            return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
-        case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
-            return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
-        case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
-            return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
-        case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
-            return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
-        case XGL_BLEND_ONE_MINUS_SRC_COLOR:
-            return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
-        case XGL_BLEND_SRC1_ALPHA:
-            return "XGL_BLEND_SRC1_ALPHA";
-        case XGL_BLEND_SRC1_COLOR:
-            return "XGL_BLEND_SRC1_COLOR";
-        case XGL_BLEND_SRC_ALPHA:
-            return "XGL_BLEND_SRC_ALPHA";
-        case XGL_BLEND_SRC_ALPHA_SATURATE:
-            return "XGL_BLEND_SRC_ALPHA_SATURATE";
-        case XGL_BLEND_SRC_COLOR:
-            return "XGL_BLEND_SRC_COLOR";
-        case XGL_BLEND_ZERO:
-            return "XGL_BLEND_ZERO";
-        default:
-            return "Unhandled XGL_BLEND";
-    }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
-    {
-        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
-            return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
-        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
-            return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
-        default:
-            return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
-    }
-}
-
-
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
-    switch ((XGL_CULL_MODE)input_value)
-    {
-        case XGL_CULL_BACK:
-            return "XGL_CULL_BACK";
-        case XGL_CULL_FRONT:
-            return "XGL_CULL_FRONT";
-        case XGL_CULL_FRONT_AND_BACK:
-            return "XGL_CULL_FRONT_AND_BACK";
-        case XGL_CULL_NONE:
-            return "XGL_CULL_NONE";
-        default:
-            return "Unhandled XGL_CULL_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
-    {
-        case XGL_BUFFER_VIEW_RAW:
-            return "XGL_BUFFER_VIEW_RAW";
-        case XGL_BUFFER_VIEW_STRUCTURED:
-            return "XGL_BUFFER_VIEW_STRUCTURED";
-        case XGL_BUFFER_VIEW_TYPED:
-            return "XGL_BUFFER_VIEW_TYPED";
-        default:
-            return "Unhandled XGL_BUFFER_VIEW_TYPE";
+            return "Unhandled XGL_STATE_BIND_POINT";
     }
 }
 
@@ -917,194 +487,20 @@
 }
 
 
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
 {
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    switch ((XGL_OBJECT_INFO_TYPE)input_value)
     {
-        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
-            return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
-        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
-            return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
-        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
-            return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
-        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
-            return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
-        case XGL_IMAGE_CREATE_SPARSE_BIT:
-            return "XGL_IMAGE_CREATE_SPARSE_BIT";
+        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+            return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
         default:
-            return "Unhandled XGL_IMAGE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
-{
-    switch ((XGL_TEX_ADDRESS)input_value)
-    {
-        case XGL_TEX_ADDRESS_CLAMP:
-            return "XGL_TEX_ADDRESS_CLAMP";
-        case XGL_TEX_ADDRESS_CLAMP_BORDER:
-            return "XGL_TEX_ADDRESS_CLAMP_BORDER";
-        case XGL_TEX_ADDRESS_MIRROR:
-            return "XGL_TEX_ADDRESS_MIRROR";
-        case XGL_TEX_ADDRESS_MIRROR_ONCE:
-            return "XGL_TEX_ADDRESS_MIRROR_ONCE";
-        case XGL_TEX_ADDRESS_WRAP:
-            return "XGL_TEX_ADDRESS_WRAP";
-        default:
-            return "Unhandled XGL_TEX_ADDRESS";
-    }
-}
-
-
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
-    switch ((XGL_QUEUE_FLAGS)input_value)
-    {
-        case XGL_QUEUE_COMPUTE_BIT:
-            return "XGL_QUEUE_COMPUTE_BIT";
-        case XGL_QUEUE_DMA_BIT:
-            return "XGL_QUEUE_DMA_BIT";
-        case XGL_QUEUE_EXTENDED_BIT:
-            return "XGL_QUEUE_EXTENDED_BIT";
-        case XGL_QUEUE_GRAPHICS_BIT:
-            return "XGL_QUEUE_GRAPHICS_BIT";
-        default:
-            return "Unhandled XGL_QUEUE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
-    switch ((XGL_QUERY_TYPE)input_value)
-    {
-        case XGL_QUERY_OCCLUSION:
-            return "XGL_QUERY_OCCLUSION";
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return "XGL_QUERY_PIPELINE_STATISTICS";
-        default:
-            return "Unhandled XGL_QUERY_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
-    switch ((XGL_IMAGE_LAYOUT)input_value)
-    {
-        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_GENERAL:
-            return "XGL_IMAGE_LAYOUT_GENERAL";
-        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
-        default:
-            return "Unhandled XGL_IMAGE_LAYOUT";
-    }
-}
-
-
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
-    {
-        case XGL_QUERY_IMPRECISE_DATA_BIT:
-            return "XGL_QUERY_IMPRECISE_DATA_BIT";
-        default:
-            return "Unhandled XGL_QUERY_CONTROL_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
-{
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
-            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
-        default:
-            return "Unhandled XGL_FORMAT_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
-    {
-        case XGL_SHADER_STAGE_COMPUTE:
-            return "XGL_SHADER_STAGE_COMPUTE";
-        case XGL_SHADER_STAGE_FRAGMENT:
-            return "XGL_SHADER_STAGE_FRAGMENT";
-        case XGL_SHADER_STAGE_GEOMETRY:
-            return "XGL_SHADER_STAGE_GEOMETRY";
-        case XGL_SHADER_STAGE_TESS_CONTROL:
-            return "XGL_SHADER_STAGE_TESS_CONTROL";
-        case XGL_SHADER_STAGE_TESS_EVALUATION:
-            return "XGL_SHADER_STAGE_TESS_EVALUATION";
-        case XGL_SHADER_STAGE_VERTEX:
-            return "XGL_SHADER_STAGE_VERTEX";
-        default:
-            return "Unhandled XGL_PIPELINE_SHADER_STAGE";
-    }
-}
-
-
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
-    switch ((XGL_COORDINATE_ORIGIN)input_value)
-    {
-        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
-            return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
-        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
-            return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
-        default:
-            return "Unhandled XGL_COORDINATE_ORIGIN";
-    }
-}
-
-
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
-    switch ((XGL_VALIDATION_LEVEL)input_value)
-    {
-        case XGL_VALIDATION_LEVEL_0:
-            return "XGL_VALIDATION_LEVEL_0";
-        case XGL_VALIDATION_LEVEL_1:
-            return "XGL_VALIDATION_LEVEL_1";
-        case XGL_VALIDATION_LEVEL_2:
-            return "XGL_VALIDATION_LEVEL_2";
-        case XGL_VALIDATION_LEVEL_3:
-            return "XGL_VALIDATION_LEVEL_3";
-        case XGL_VALIDATION_LEVEL_4:
-            return "XGL_VALIDATION_LEVEL_4";
-        default:
-            return "Unhandled XGL_VALIDATION_LEVEL";
-    }
-}
-
-
-static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
-    {
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
-            return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
-            return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
-        default:
-            return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+            return "Unhandled XGL_OBJECT_INFO_TYPE";
     }
 }
 
@@ -1123,84 +519,6 @@
 }
 
 
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
-    {
-        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
-            return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
-        case XGL_BUFFER_CREATE_SPARSE_BIT:
-            return "XGL_BUFFER_CREATE_SPARSE_BIT";
-        default:
-            return "Unhandled XGL_BUFFER_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
-    switch ((XGL_SET_EVENT)input_value)
-    {
-        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
-            return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
-        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
-            return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
-        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
-            return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
-        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
-            return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
-        case XGL_SET_EVENT_TOP_OF_PIPE:
-            return "XGL_SET_EVENT_TOP_OF_PIPE";
-        case XGL_SET_EVENT_TRANSFER_COMPLETE:
-            return "XGL_SET_EVENT_TRANSFER_COMPLETE";
-        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
-            return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
-        default:
-            return "Unhandled XGL_SET_EVENT";
-    }
-}
-
-
-static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
-{
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
-    {
-        case XGL_PIPELINE_BIND_POINT_COMPUTE:
-            return "XGL_PIPELINE_BIND_POINT_COMPUTE";
-        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
-            return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
-        default:
-            return "Unhandled XGL_PIPELINE_BIND_POINT";
-    }
-}
-
-
-static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
-    switch ((XGL_COMPARE_FUNC)input_value)
-    {
-        case XGL_COMPARE_ALWAYS:
-            return "XGL_COMPARE_ALWAYS";
-        case XGL_COMPARE_EQUAL:
-            return "XGL_COMPARE_EQUAL";
-        case XGL_COMPARE_GREATER:
-            return "XGL_COMPARE_GREATER";
-        case XGL_COMPARE_GREATER_EQUAL:
-            return "XGL_COMPARE_GREATER_EQUAL";
-        case XGL_COMPARE_LESS:
-            return "XGL_COMPARE_LESS";
-        case XGL_COMPARE_LESS_EQUAL:
-            return "XGL_COMPARE_LESS_EQUAL";
-        case XGL_COMPARE_NEVER:
-            return "XGL_COMPARE_NEVER";
-        case XGL_COMPARE_NOT_EQUAL:
-            return "XGL_COMPARE_NOT_EQUAL";
-        default:
-            return "Unhandled XGL_COMPARE_FUNC";
-    }
-}
-
-
 static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
 {
     switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
@@ -1247,18 +565,224 @@
 }
 
 
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_FILL_MODE)input_value)
+    switch ((XGL_TEX_ADDRESS)input_value)
     {
-        case XGL_FILL_POINTS:
-            return "XGL_FILL_POINTS";
-        case XGL_FILL_SOLID:
-            return "XGL_FILL_SOLID";
-        case XGL_FILL_WIREFRAME:
-            return "XGL_FILL_WIREFRAME";
+        case XGL_TEX_ADDRESS_CLAMP:
+            return "XGL_TEX_ADDRESS_CLAMP";
+        case XGL_TEX_ADDRESS_CLAMP_BORDER:
+            return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+        case XGL_TEX_ADDRESS_MIRROR:
+            return "XGL_TEX_ADDRESS_MIRROR";
+        case XGL_TEX_ADDRESS_MIRROR_ONCE:
+            return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+        case XGL_TEX_ADDRESS_WRAP:
+            return "XGL_TEX_ADDRESS_WRAP";
         default:
-            return "Unhandled XGL_FILL_MODE";
+            return "Unhandled XGL_TEX_ADDRESS";
+    }
+}
+
+
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+    {
+        case XGL_TOPOLOGY_LINE_LIST:
+            return "XGL_TOPOLOGY_LINE_LIST";
+        case XGL_TOPOLOGY_LINE_LIST_ADJ:
+            return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+        case XGL_TOPOLOGY_LINE_STRIP:
+            return "XGL_TOPOLOGY_LINE_STRIP";
+        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+            return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+        case XGL_TOPOLOGY_PATCH:
+            return "XGL_TOPOLOGY_PATCH";
+        case XGL_TOPOLOGY_POINT_LIST:
+            return "XGL_TOPOLOGY_POINT_LIST";
+        case XGL_TOPOLOGY_QUAD_LIST:
+            return "XGL_TOPOLOGY_QUAD_LIST";
+        case XGL_TOPOLOGY_QUAD_STRIP:
+            return "XGL_TOPOLOGY_QUAD_STRIP";
+        case XGL_TOPOLOGY_RECT_LIST:
+            return "XGL_TOPOLOGY_RECT_LIST";
+        case XGL_TOPOLOGY_TRIANGLE_LIST:
+            return "XGL_TOPOLOGY_TRIANGLE_LIST";
+        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+            return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+        case XGL_TOPOLOGY_TRIANGLE_STRIP:
+            return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+            return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+        default:
+            return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    {
+        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+            return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+            return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+    }
+}
+
+
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+        default:
+            return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+    switch ((XGL_STENCIL_OP)input_value)
+    {
+        case XGL_STENCIL_OP_DEC_CLAMP:
+            return "XGL_STENCIL_OP_DEC_CLAMP";
+        case XGL_STENCIL_OP_DEC_WRAP:
+            return "XGL_STENCIL_OP_DEC_WRAP";
+        case XGL_STENCIL_OP_INC_CLAMP:
+            return "XGL_STENCIL_OP_INC_CLAMP";
+        case XGL_STENCIL_OP_INC_WRAP:
+            return "XGL_STENCIL_OP_INC_WRAP";
+        case XGL_STENCIL_OP_INVERT:
+            return "XGL_STENCIL_OP_INVERT";
+        case XGL_STENCIL_OP_KEEP:
+            return "XGL_STENCIL_OP_KEEP";
+        case XGL_STENCIL_OP_REPLACE:
+            return "XGL_STENCIL_OP_REPLACE";
+        case XGL_STENCIL_OP_ZERO:
+            return "XGL_STENCIL_OP_ZERO";
+        default:
+            return "Unhandled XGL_STENCIL_OP";
+    }
+}
+
+
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    {
+        case XGL_BUFFER_VIEW_RAW:
+            return "XGL_BUFFER_VIEW_RAW";
+        case XGL_BUFFER_VIEW_STRUCTURED:
+            return "XGL_BUFFER_VIEW_STRUCTURED";
+        case XGL_BUFFER_VIEW_TYPED:
+            return "XGL_BUFFER_VIEW_TYPED";
+        default:
+            return "Unhandled XGL_BUFFER_VIEW_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    {
+        case XGL_GPU_TYPE_DISCRETE:
+            return "XGL_GPU_TYPE_DISCRETE";
+        case XGL_GPU_TYPE_INTEGRATED:
+            return "XGL_GPU_TYPE_INTEGRATED";
+        case XGL_GPU_TYPE_OTHER:
+            return "XGL_GPU_TYPE_OTHER";
+        case XGL_GPU_TYPE_VIRTUAL:
+            return "XGL_GPU_TYPE_VIRTUAL";
+        default:
+            return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    {
+        case XGL_PROVOKING_VERTEX_FIRST:
+            return "XGL_PROVOKING_VERTEX_FIRST";
+        case XGL_PROVOKING_VERTEX_LAST:
+            return "XGL_PROVOKING_VERTEX_LAST";
+        default:
+            return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
+    }
+}
+
+
+static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+{
+    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+    {
+        case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+            return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
+        case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+            return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
+        case XGL_FORMAT_CONVERSION_BIT:
+            return "XGL_FORMAT_CONVERSION_BIT";
+        case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+            return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
+        case XGL_FORMAT_IMAGE_COPY_BIT:
+            return "XGL_FORMAT_IMAGE_COPY_BIT";
+        case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+            return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
+        case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+            return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
+        case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+            return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
+        case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+            return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
+        case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+            return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
+        default:
+            return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+    switch ((XGL_COORDINATE_ORIGIN)input_value)
+    {
+        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+            return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+            return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+        default:
+            return "Unhandled XGL_COORDINATE_ORIGIN";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+    switch ((XGL_MEMORY_PRIORITY)input_value)
+    {
+        case XGL_MEMORY_PRIORITY_HIGH:
+            return "XGL_MEMORY_PRIORITY_HIGH";
+        case XGL_MEMORY_PRIORITY_LOW:
+            return "XGL_MEMORY_PRIORITY_LOW";
+        case XGL_MEMORY_PRIORITY_NORMAL:
+            return "XGL_MEMORY_PRIORITY_NORMAL";
+        case XGL_MEMORY_PRIORITY_UNUSED:
+            return "XGL_MEMORY_PRIORITY_UNUSED";
+        case XGL_MEMORY_PRIORITY_VERY_HIGH:
+            return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+        case XGL_MEMORY_PRIORITY_VERY_LOW:
+            return "XGL_MEMORY_PRIORITY_VERY_LOW";
+        default:
+            return "Unhandled XGL_MEMORY_PRIORITY";
     }
 }
 
@@ -1287,6 +811,534 @@
 }
 
 
+static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
+{
+    switch ((XGL_BLEND)input_value)
+    {
+        case XGL_BLEND_CONSTANT_ALPHA:
+            return "XGL_BLEND_CONSTANT_ALPHA";
+        case XGL_BLEND_CONSTANT_COLOR:
+            return "XGL_BLEND_CONSTANT_COLOR";
+        case XGL_BLEND_DEST_ALPHA:
+            return "XGL_BLEND_DEST_ALPHA";
+        case XGL_BLEND_DEST_COLOR:
+            return "XGL_BLEND_DEST_COLOR";
+        case XGL_BLEND_ONE:
+            return "XGL_BLEND_ONE";
+        case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+            return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
+        case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+            return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
+        case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+            return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
+        case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+            return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
+        case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+            return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
+        case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+            return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
+        case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+            return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
+        case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+            return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
+        case XGL_BLEND_SRC1_ALPHA:
+            return "XGL_BLEND_SRC1_ALPHA";
+        case XGL_BLEND_SRC1_COLOR:
+            return "XGL_BLEND_SRC1_COLOR";
+        case XGL_BLEND_SRC_ALPHA:
+            return "XGL_BLEND_SRC_ALPHA";
+        case XGL_BLEND_SRC_ALPHA_SATURATE:
+            return "XGL_BLEND_SRC_ALPHA_SATURATE";
+        case XGL_BLEND_SRC_COLOR:
+            return "XGL_BLEND_SRC_COLOR";
+        case XGL_BLEND_ZERO:
+            return "XGL_BLEND_ZERO";
+        default:
+            return "Unhandled XGL_BLEND";
+    }
+}
+
+
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+{
+    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+    {
+        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+            return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
+        case XGL_BUFFER_CREATE_SPARSE_BIT:
+            return "XGL_BUFFER_CREATE_SPARSE_BIT";
+        default:
+            return "Unhandled XGL_BUFFER_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+    switch ((XGL_FACE_ORIENTATION)input_value)
+    {
+        case XGL_FRONT_FACE_CCW:
+            return "XGL_FRONT_FACE_CCW";
+        case XGL_FRONT_FACE_CW:
+            return "XGL_FRONT_FACE_CW";
+        default:
+            return "Unhandled XGL_FACE_ORIENTATION";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    {
+        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+            return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+        case XGL_MEMORY_OUTPUT_COPY_BIT:
+            return "XGL_MEMORY_OUTPUT_COPY_BIT";
+        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+            return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+            return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+            return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+        default:
+            return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+    switch ((XGL_IMAGE_TYPE)input_value)
+    {
+        case XGL_IMAGE_1D:
+            return "XGL_IMAGE_1D";
+        case XGL_IMAGE_2D:
+            return "XGL_IMAGE_2D";
+        case XGL_IMAGE_3D:
+            return "XGL_IMAGE_3D";
+        default:
+            return "Unhandled XGL_IMAGE_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+    switch ((XGL_MEMORY_TYPE)input_value)
+    {
+        case XGL_MEMORY_TYPE_BUFFER:
+            return "XGL_MEMORY_TYPE_BUFFER";
+        case XGL_MEMORY_TYPE_IMAGE:
+            return "XGL_MEMORY_TYPE_IMAGE";
+        case XGL_MEMORY_TYPE_OTHER:
+            return "XGL_MEMORY_TYPE_OTHER";
+        default:
+            return "Unhandled XGL_MEMORY_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+{
+    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    {
+        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
+        default:
+            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+    switch ((XGL_BLEND_FUNC)input_value)
+    {
+        case XGL_BLEND_FUNC_ADD:
+            return "XGL_BLEND_FUNC_ADD";
+        case XGL_BLEND_FUNC_MAX:
+            return "XGL_BLEND_FUNC_MAX";
+        case XGL_BLEND_FUNC_MIN:
+            return "XGL_BLEND_FUNC_MIN";
+        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+            return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+        case XGL_BLEND_FUNC_SUBTRACT:
+            return "XGL_BLEND_FUNC_SUBTRACT";
+        default:
+            return "Unhandled XGL_BLEND_FUNC";
+    }
+}
+
+
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+    switch ((XGL_FILL_MODE)input_value)
+    {
+        case XGL_FILL_POINTS:
+            return "XGL_FILL_POINTS";
+        case XGL_FILL_SOLID:
+            return "XGL_FILL_SOLID";
+        case XGL_FILL_WIREFRAME:
+            return "XGL_FILL_WIREFRAME";
+        default:
+            return "Unhandled XGL_FILL_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+{
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+    {
+        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+            return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+            return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+    }
+}
+
+
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    {
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
+            return "XGL_QUERY_IMPRECISE_DATA_BIT";
+        default:
+            return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+    switch ((XGL_QUEUE_TYPE)input_value)
+    {
+        case XGL_QUEUE_TYPE_COMPUTE:
+            return "XGL_QUEUE_TYPE_COMPUTE";
+        case XGL_QUEUE_TYPE_DMA:
+            return "XGL_QUEUE_TYPE_DMA";
+        case XGL_QUEUE_TYPE_GRAPHICS:
+            return "XGL_QUEUE_TYPE_GRAPHICS";
+        default:
+            return "Unhandled XGL_QUEUE_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    {
+        case XGL_DESCRIPTOR_TYPE_IMAGE:
+            return "XGL_DESCRIPTOR_TYPE_IMAGE";
+        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
+        case XGL_DESCRIPTOR_TYPE_SAMPLER:
+            return "XGL_DESCRIPTOR_TYPE_SAMPLER";
+        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+            return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
+        case XGL_DESCRIPTOR_TYPE_TEXTURE:
+            return "XGL_DESCRIPTOR_TYPE_TEXTURE";
+        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+    switch ((XGL_TEX_FILTER)input_value)
+    {
+        case XGL_TEX_FILTER_LINEAR:
+            return "XGL_TEX_FILTER_LINEAR";
+        case XGL_TEX_FILTER_NEAREST:
+            return "XGL_TEX_FILTER_NEAREST";
+        default:
+            return "Unhandled XGL_TEX_FILTER";
+    }
+}
+
+
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+    switch ((XGL_SET_EVENT)input_value)
+    {
+        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+            return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
+        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+            return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+            return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
+        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+            return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+        case XGL_SET_EVENT_TOP_OF_PIPE:
+            return "XGL_SET_EVENT_TOP_OF_PIPE";
+        case XGL_SET_EVENT_TRANSFER_COMPLETE:
+            return "XGL_SET_EVENT_TRANSFER_COMPLETE";
+        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+            return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
+        default:
+            return "Unhandled XGL_SET_EVENT";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    {
+        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+            return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+            return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+            return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+            return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+        case XGL_IMAGE_CREATE_SPARSE_BIT:
+            return "XGL_IMAGE_CREATE_SPARSE_BIT";
+        default:
+            return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+    switch ((XGL_COMPARE_FUNC)input_value)
+    {
+        case XGL_COMPARE_ALWAYS:
+            return "XGL_COMPARE_ALWAYS";
+        case XGL_COMPARE_EQUAL:
+            return "XGL_COMPARE_EQUAL";
+        case XGL_COMPARE_GREATER:
+            return "XGL_COMPARE_GREATER";
+        case XGL_COMPARE_GREATER_EQUAL:
+            return "XGL_COMPARE_GREATER_EQUAL";
+        case XGL_COMPARE_LESS:
+            return "XGL_COMPARE_LESS";
+        case XGL_COMPARE_LESS_EQUAL:
+            return "XGL_COMPARE_LESS_EQUAL";
+        case XGL_COMPARE_NEVER:
+            return "XGL_COMPARE_NEVER";
+        case XGL_COMPARE_NOT_EQUAL:
+            return "XGL_COMPARE_NOT_EQUAL";
+        default:
+            return "Unhandled XGL_COMPARE_FUNC";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+    switch ((XGL_IMAGE_LAYOUT)input_value)
+    {
+        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_GENERAL:
+            return "XGL_IMAGE_LAYOUT_GENERAL";
+        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+        default:
+            return "Unhandled XGL_IMAGE_LAYOUT";
+    }
+}
+
+
+static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+{
+    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    {
+        case XGL_SHADER_STAGE_FLAGS_ALL:
+            return "XGL_SHADER_STAGE_FLAGS_ALL";
+        case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
+        case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
+        case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
+        case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
+        case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
+        case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+        default:
+            return "Unhandled XGL_SHADER_STAGE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    {
+        case XGL_SHADER_STAGE_COMPUTE:
+            return "XGL_SHADER_STAGE_COMPUTE";
+        case XGL_SHADER_STAGE_FRAGMENT:
+            return "XGL_SHADER_STAGE_FRAGMENT";
+        case XGL_SHADER_STAGE_GEOMETRY:
+            return "XGL_SHADER_STAGE_GEOMETRY";
+        case XGL_SHADER_STAGE_TESS_CONTROL:
+            return "XGL_SHADER_STAGE_TESS_CONTROL";
+        case XGL_SHADER_STAGE_TESS_EVALUATION:
+            return "XGL_SHADER_STAGE_TESS_EVALUATION";
+        case XGL_SHADER_STAGE_VERTEX:
+            return "XGL_SHADER_STAGE_VERTEX";
+        default:
+            return "Unhandled XGL_PIPELINE_SHADER_STAGE";
+    }
+}
+
+
+static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    {
+        case XGL_CHANNEL_SWIZZLE_A:
+            return "XGL_CHANNEL_SWIZZLE_A";
+        case XGL_CHANNEL_SWIZZLE_B:
+            return "XGL_CHANNEL_SWIZZLE_B";
+        case XGL_CHANNEL_SWIZZLE_G:
+            return "XGL_CHANNEL_SWIZZLE_G";
+        case XGL_CHANNEL_SWIZZLE_ONE:
+            return "XGL_CHANNEL_SWIZZLE_ONE";
+        case XGL_CHANNEL_SWIZZLE_R:
+            return "XGL_CHANNEL_SWIZZLE_R";
+        case XGL_CHANNEL_SWIZZLE_ZERO:
+            return "XGL_CHANNEL_SWIZZLE_ZERO";
+        default:
+            return "Unhandled XGL_CHANNEL_SWIZZLE";
+    }
+}
+
+
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+    switch ((XGL_INDEX_TYPE)input_value)
+    {
+        case XGL_INDEX_16:
+            return "XGL_INDEX_16";
+        case XGL_INDEX_32:
+            return "XGL_INDEX_32";
+        case XGL_INDEX_8:
+            return "XGL_INDEX_8";
+        default:
+            return "Unhandled XGL_INDEX_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    {
+        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+            return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+            return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+            return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+        default:
+            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+    }
+}
+
+
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    {
+        case XGL_BORDER_COLOR_OPAQUE_BLACK:
+            return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+        case XGL_BORDER_COLOR_OPAQUE_WHITE:
+            return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+            return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
+        default:
+            return "Unhandled XGL_BORDER_COLOR_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+    switch ((XGL_CULL_MODE)input_value)
+    {
+        case XGL_CULL_BACK:
+            return "XGL_CULL_BACK";
+        case XGL_CULL_FRONT:
+            return "XGL_CULL_FRONT";
+        case XGL_CULL_FRONT_AND_BACK:
+            return "XGL_CULL_FRONT_AND_BACK";
+        case XGL_CULL_NONE:
+            return "XGL_CULL_NONE";
+        default:
+            return "Unhandled XGL_CULL_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    {
+        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+            return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+            return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+        default:
+            return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+        default:
+            return "Unhandled XGL_FORMAT_INFO_TYPE";
+    }
+}
+
+
 static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
 {
     switch ((XGL_FORMAT)input_value)
@@ -1631,160 +1683,172 @@
 }
 
 
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_TEX_MIPMAP_MODE)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-            return "XGL_FRONT_FACE_CCW";
-        case XGL_FRONT_FACE_CW:
-            return "XGL_FRONT_FACE_CW";
+        case XGL_TEX_MIPMAP_BASE:
+            return "XGL_TEX_MIPMAP_BASE";
+        case XGL_TEX_MIPMAP_LINEAR:
+            return "XGL_TEX_MIPMAP_LINEAR";
+        case XGL_TEX_MIPMAP_NEAREST:
+            return "XGL_TEX_MIPMAP_NEAREST";
         default:
-            return "Unhandled XGL_FACE_ORIENTATION";
+            return "Unhandled XGL_TEX_MIPMAP_MODE";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_QUEUE_FLAGS)input_value)
     {
-        case XGL_IMAGE_1D:
-            return "XGL_IMAGE_1D";
-        case XGL_IMAGE_2D:
-            return "XGL_IMAGE_2D";
-        case XGL_IMAGE_3D:
-            return "XGL_IMAGE_3D";
+        case XGL_QUEUE_COMPUTE_BIT:
+            return "XGL_QUEUE_COMPUTE_BIT";
+        case XGL_QUEUE_DMA_BIT:
+            return "XGL_QUEUE_DMA_BIT";
+        case XGL_QUEUE_EXTENDED_BIT:
+            return "XGL_QUEUE_EXTENDED_BIT";
+        case XGL_QUEUE_GRAPHICS_BIT:
+            return "XGL_QUEUE_GRAPHICS_BIT";
         default:
-            return "Unhandled XGL_IMAGE_TYPE";
+            return "Unhandled XGL_QUEUE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
 {
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    switch ((XGL_LOGIC_OP)input_value)
     {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-            return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-            return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
-            return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+        case XGL_LOGIC_OP_AND:
+            return "XGL_LOGIC_OP_AND";
+        case XGL_LOGIC_OP_AND_INVERTED:
+            return "XGL_LOGIC_OP_AND_INVERTED";
+        case XGL_LOGIC_OP_AND_REVERSE:
+            return "XGL_LOGIC_OP_AND_REVERSE";
+        case XGL_LOGIC_OP_CLEAR:
+            return "XGL_LOGIC_OP_CLEAR";
+        case XGL_LOGIC_OP_COPY:
+            return "XGL_LOGIC_OP_COPY";
+        case XGL_LOGIC_OP_COPY_INVERTED:
+            return "XGL_LOGIC_OP_COPY_INVERTED";
+        case XGL_LOGIC_OP_EQUIV:
+            return "XGL_LOGIC_OP_EQUIV";
+        case XGL_LOGIC_OP_INVERT:
+            return "XGL_LOGIC_OP_INVERT";
+        case XGL_LOGIC_OP_NAND:
+            return "XGL_LOGIC_OP_NAND";
+        case XGL_LOGIC_OP_NOOP:
+            return "XGL_LOGIC_OP_NOOP";
+        case XGL_LOGIC_OP_NOR:
+            return "XGL_LOGIC_OP_NOR";
+        case XGL_LOGIC_OP_OR:
+            return "XGL_LOGIC_OP_OR";
+        case XGL_LOGIC_OP_OR_INVERTED:
+            return "XGL_LOGIC_OP_OR_INVERTED";
+        case XGL_LOGIC_OP_OR_REVERSE:
+            return "XGL_LOGIC_OP_OR_REVERSE";
+        case XGL_LOGIC_OP_SET:
+            return "XGL_LOGIC_OP_SET";
+        case XGL_LOGIC_OP_XOR:
+            return "XGL_LOGIC_OP_XOR";
         default:
-            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+            return "Unhandled XGL_LOGIC_OP";
     }
 }
 
 
-static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
 {
-    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    switch ((XGL_VALIDATION_LEVEL)input_value)
     {
-        case XGL_CHANNEL_SWIZZLE_A:
-            return "XGL_CHANNEL_SWIZZLE_A";
-        case XGL_CHANNEL_SWIZZLE_B:
-            return "XGL_CHANNEL_SWIZZLE_B";
-        case XGL_CHANNEL_SWIZZLE_G:
-            return "XGL_CHANNEL_SWIZZLE_G";
-        case XGL_CHANNEL_SWIZZLE_ONE:
-            return "XGL_CHANNEL_SWIZZLE_ONE";
-        case XGL_CHANNEL_SWIZZLE_R:
-            return "XGL_CHANNEL_SWIZZLE_R";
-        case XGL_CHANNEL_SWIZZLE_ZERO:
-            return "XGL_CHANNEL_SWIZZLE_ZERO";
+        case XGL_VALIDATION_LEVEL_0:
+            return "XGL_VALIDATION_LEVEL_0";
+        case XGL_VALIDATION_LEVEL_1:
+            return "XGL_VALIDATION_LEVEL_1";
+        case XGL_VALIDATION_LEVEL_2:
+            return "XGL_VALIDATION_LEVEL_2";
+        case XGL_VALIDATION_LEVEL_3:
+            return "XGL_VALIDATION_LEVEL_3";
+        case XGL_VALIDATION_LEVEL_4:
+            return "XGL_VALIDATION_LEVEL_4";
         default:
-            return "Unhandled XGL_CHANNEL_SWIZZLE";
+            return "Unhandled XGL_VALIDATION_LEVEL";
     }
 }
 
 
-static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
 {
-    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
     {
-        case XGL_SHADER_STAGE_FLAGS_ALL:
-            return "XGL_SHADER_STAGE_FLAGS_ALL";
-        case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
-        case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
-        case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
-        case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
-        case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
-        case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+            return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+            return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+        case XGL_IMAGE_USAGE_GENERAL:
+            return "XGL_IMAGE_USAGE_GENERAL";
+        case XGL_IMAGE_USAGE_IMAGE_BIT:
+            return "XGL_IMAGE_USAGE_IMAGE_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+        case XGL_IMAGE_USAGE_TEXTURE_BIT:
+            return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+            return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+            return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
         default:
-            return "Unhandled XGL_SHADER_STAGE_FLAGS";
+            return "Unhandled XGL_IMAGE_USAGE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
 {
-    switch ((XGL_IMAGE_ASPECT)input_value)
+    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
     {
-        case XGL_IMAGE_ASPECT_COLOR:
-            return "XGL_IMAGE_ASPECT_COLOR";
-        case XGL_IMAGE_ASPECT_DEPTH:
-            return "XGL_IMAGE_ASPECT_DEPTH";
-        case XGL_IMAGE_ASPECT_STENCIL:
-            return "XGL_IMAGE_ASPECT_STENCIL";
+        case XGL_SYSTEM_ALLOC_API_OBJECT:
+            return "XGL_SYSTEM_ALLOC_API_OBJECT";
+        case XGL_SYSTEM_ALLOC_DEBUG:
+            return "XGL_SYSTEM_ALLOC_DEBUG";
+        case XGL_SYSTEM_ALLOC_INTERNAL:
+            return "XGL_SYSTEM_ALLOC_INTERNAL";
+        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+            return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+            return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
         default:
-            return "Unhandled XGL_IMAGE_ASPECT";
+            return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
     {
-        case XGL_BUFFER_USAGE_GENERAL:
-            return "XGL_BUFFER_USAGE_GENERAL";
-        case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
-            return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
-        case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
-            return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
-        case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
-            return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
-        case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
-            return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-            return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
-            return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
-            return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
-        case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
-            return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
-        case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
-            return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
-        case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
-            return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
-        case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
-            return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
-        case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
-            return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
-        case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
-            return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
+        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+            return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+            return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+            return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+            return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
         default:
-            return "Unhandled XGL_BUFFER_USAGE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
-    {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
-        default:
-            return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+            return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
     }
 }
 
@@ -1816,67 +1880,3 @@
     }
 }
 
-
-static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
-    switch ((XGL_INDEX_TYPE)input_value)
-    {
-        case XGL_INDEX_16:
-            return "XGL_INDEX_16";
-        case XGL_INDEX_32:
-            return "XGL_INDEX_32";
-        case XGL_INDEX_8:
-            return "XGL_INDEX_8";
-        default:
-            return "Unhandled XGL_INDEX_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
-    {
-        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
-        default:
-            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
-{
-    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
-    {
-        case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
-            return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
-        case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
-            return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
-        case XGL_FORMAT_CONVERSION_BIT:
-            return "XGL_FORMAT_CONVERSION_BIT";
-        case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
-            return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
-        case XGL_FORMAT_IMAGE_COPY_BIT:
-            return "XGL_FORMAT_IMAGE_COPY_BIT";
-        case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
-            return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
-        case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
-            return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
-        case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
-            return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
-        case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
-            return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
-        case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
-            return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
-        default:
-            return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
-    }
-}
-
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h
index b45590b..e80a1d1 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h
@@ -3,51 +3,12 @@
 #include <xgl.h>
 
 
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+    switch ((XGL_DEPTH_MODE)input_value)
     {
-        case XGL_TOPOLOGY_LINE_LIST:
-        case XGL_TOPOLOGY_LINE_LIST_ADJ:
-        case XGL_TOPOLOGY_LINE_STRIP:
-        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
-        case XGL_TOPOLOGY_PATCH:
-        case XGL_TOPOLOGY_POINT_LIST:
-        case XGL_TOPOLOGY_QUAD_LIST:
-        case XGL_TOPOLOGY_QUAD_STRIP:
-        case XGL_TOPOLOGY_RECT_LIST:
-        case XGL_TOPOLOGY_TRIANGLE_LIST:
-        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
-        case XGL_TOPOLOGY_TRIANGLE_STRIP:
-        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
-    switch ((XGL_BLEND_FUNC)input_value)
-    {
-        case XGL_BLEND_FUNC_ADD:
-        case XGL_BLEND_FUNC_MAX:
-        case XGL_BLEND_FUNC_MIN:
-        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
-        case XGL_BLEND_FUNC_SUBTRACT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
-    {
-        case XGL_MEMORY_REF_READ_ONLY_BIT:
+        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+        case XGL_DEPTH_MODE_ZERO_TO_ONE:
             return 1;
         default:
             return 0;
@@ -70,15 +31,12 @@
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_PIPELINE_BIND_POINT)input_value)
     {
-        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
-        case XGL_MEMORY_OUTPUT_COPY_BIT:
-        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
-        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+        case XGL_PIPELINE_BIND_POINT_COMPUTE:
+        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -86,12 +44,11 @@
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    switch ((XGL_MEMORY_REF_FLAGS)input_value)
     {
-        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
-        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+        case XGL_MEMORY_REF_READ_ONLY_BIT:
             return 1;
         default:
             return 0;
@@ -99,107 +56,11 @@
 }
 
 
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_STATE_BIND_POINT)input_value)
+    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
     {
-        case XGL_STATE_BIND_COLOR_BLEND:
-        case XGL_STATE_BIND_DEPTH_STENCIL:
-        case XGL_STATE_BIND_RASTER:
-        case XGL_STATE_BIND_VIEWPORT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
-{
-    switch ((XGL_LOGIC_OP)input_value)
-    {
-        case XGL_LOGIC_OP_AND:
-        case XGL_LOGIC_OP_AND_INVERTED:
-        case XGL_LOGIC_OP_AND_REVERSE:
-        case XGL_LOGIC_OP_CLEAR:
-        case XGL_LOGIC_OP_COPY:
-        case XGL_LOGIC_OP_COPY_INVERTED:
-        case XGL_LOGIC_OP_EQUIV:
-        case XGL_LOGIC_OP_INVERT:
-        case XGL_LOGIC_OP_NAND:
-        case XGL_LOGIC_OP_NOOP:
-        case XGL_LOGIC_OP_NOR:
-        case XGL_LOGIC_OP_OR:
-        case XGL_LOGIC_OP_OR_INVERTED:
-        case XGL_LOGIC_OP_OR_REVERSE:
-        case XGL_LOGIC_OP_SET:
-        case XGL_LOGIC_OP_XOR:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
-    {
-        case XGL_DESCRIPTOR_TYPE_IMAGE:
-        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
-        case XGL_DESCRIPTOR_TYPE_SAMPLER:
-        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
-        case XGL_DESCRIPTOR_TYPE_TEXTURE:
-        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
-{
-    switch ((XGL_MEMORY_TYPE)input_value)
-    {
-        case XGL_MEMORY_TYPE_BUFFER:
-        case XGL_MEMORY_TYPE_IMAGE:
-        case XGL_MEMORY_TYPE_OTHER:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
-    switch ((XGL_MEMORY_PRIORITY)input_value)
-    {
-        case XGL_MEMORY_PRIORITY_HIGH:
-        case XGL_MEMORY_PRIORITY_LOW:
-        case XGL_MEMORY_PRIORITY_NORMAL:
-        case XGL_MEMORY_PRIORITY_UNUSED:
-        case XGL_MEMORY_PRIORITY_VERY_HIGH:
-        case XGL_MEMORY_PRIORITY_VERY_LOW:
+        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
             return 1;
         default:
             return 0;
@@ -221,12 +82,12 @@
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 {
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    switch ((XGL_QUERY_TYPE)input_value)
     {
-        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
-        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+        case XGL_QUERY_OCCLUSION:
+        case XGL_QUERY_PIPELINE_STATISTICS:
             return 1;
         default:
             return 0;
@@ -248,13 +109,12 @@
 }
 
 
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
 {
-    switch ((XGL_QUEUE_TYPE)input_value)
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
     {
-        case XGL_QUEUE_TYPE_COMPUTE:
-        case XGL_QUEUE_TYPE_DMA:
-        case XGL_QUEUE_TYPE_GRAPHICS:
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
             return 1;
         default:
             return 0;
@@ -262,28 +122,12 @@
 }
 
 
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
     {
-        case XGL_SYSTEM_ALLOC_API_OBJECT:
-        case XGL_SYSTEM_ALLOC_DEBUG:
-        case XGL_SYSTEM_ALLOC_INTERNAL:
-        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
-        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
-    switch ((XGL_DEPTH_MODE)input_value)
-    {
-        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
-        case XGL_DEPTH_MODE_ZERO_TO_ONE:
+        case XGL_TIMESTAMP_BOTTOM:
+        case XGL_TIMESTAMP_TOP:
             return 1;
         default:
             return 0;
@@ -304,20 +148,13 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 {
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+    switch ((XGL_IMAGE_ASPECT)input_value)
     {
-        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
-        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
-        case XGL_IMAGE_USAGE_GENERAL:
-        case XGL_IMAGE_USAGE_IMAGE_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
-        case XGL_IMAGE_USAGE_TEXTURE_BIT:
-        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
-        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+        case XGL_IMAGE_ASPECT_COLOR:
+        case XGL_IMAGE_ASPECT_DEPTH:
+        case XGL_IMAGE_ASPECT_STENCIL:
             return 1;
         default:
             return 0;
@@ -325,14 +162,12 @@
 }
 
 
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
     {
-        case XGL_GPU_TYPE_DISCRETE:
-        case XGL_GPU_TYPE_INTEGRATED:
-        case XGL_GPU_TYPE_OTHER:
-        case XGL_GPU_TYPE_VIRTUAL:
+        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
             return 1;
         default:
             return 0;
@@ -340,18 +175,11 @@
 }
 
 
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_STENCIL_OP)input_value)
+    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
     {
-        case XGL_STENCIL_OP_DEC_CLAMP:
-        case XGL_STENCIL_OP_DEC_WRAP:
-        case XGL_STENCIL_OP_INC_CLAMP:
-        case XGL_STENCIL_OP_INC_WRAP:
-        case XGL_STENCIL_OP_INVERT:
-        case XGL_STENCIL_OP_KEEP:
-        case XGL_STENCIL_OP_REPLACE:
-        case XGL_STENCIL_OP_ZERO:
+        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
             return 1;
         default:
             return 0;
@@ -359,13 +187,14 @@
 }
 
 
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
 {
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
     {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
             return 1;
         default:
             return 0;
@@ -373,71 +202,24 @@
 }
 
 
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
 {
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
     {
-        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
-        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
-        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
-        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
-        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
-        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
-        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
-    {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
-    {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
-        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
-        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
-        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
-    {
-        case XGL_TEX_MIPMAP_BASE:
-        case XGL_TEX_MIPMAP_LINEAR:
-        case XGL_TEX_MIPMAP_NEAREST:
+        case XGL_BUFFER_USAGE_GENERAL:
+        case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
+        case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
+        case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
+        case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
+        case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
+        case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
+        case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
+        case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
+        case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
+        case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
             return 1;
         default:
             return 0;
@@ -511,125 +293,14 @@
 }
 
 
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
+    switch ((XGL_STATE_BIND_POINT)input_value)
     {
-        case XGL_TIMESTAMP_BOTTOM:
-        case XGL_TIMESTAMP_TOP:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
-    {
-        case XGL_PROVOKING_VERTEX_FIRST:
-        case XGL_PROVOKING_VERTEX_LAST:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
-{
-    switch ((XGL_TEX_FILTER)input_value)
-    {
-        case XGL_TEX_FILTER_LINEAR:
-        case XGL_TEX_FILTER_NEAREST:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
-{
-    switch ((XGL_BLEND)input_value)
-    {
-        case XGL_BLEND_CONSTANT_ALPHA:
-        case XGL_BLEND_CONSTANT_COLOR:
-        case XGL_BLEND_DEST_ALPHA:
-        case XGL_BLEND_DEST_COLOR:
-        case XGL_BLEND_ONE:
-        case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
-        case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
-        case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
-        case XGL_BLEND_ONE_MINUS_DEST_COLOR:
-        case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
-        case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
-        case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
-        case XGL_BLEND_ONE_MINUS_SRC_COLOR:
-        case XGL_BLEND_SRC1_ALPHA:
-        case XGL_BLEND_SRC1_COLOR:
-        case XGL_BLEND_SRC_ALPHA:
-        case XGL_BLEND_SRC_ALPHA_SATURATE:
-        case XGL_BLEND_SRC_COLOR:
-        case XGL_BLEND_ZERO:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
-    {
-        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
-        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
-    switch ((XGL_CULL_MODE)input_value)
-    {
-        case XGL_CULL_BACK:
-        case XGL_CULL_FRONT:
-        case XGL_CULL_FRONT_AND_BACK:
-        case XGL_CULL_NONE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
-    {
-        case XGL_BUFFER_VIEW_RAW:
-        case XGL_BUFFER_VIEW_STRUCTURED:
-        case XGL_BUFFER_VIEW_TYPED:
+        case XGL_STATE_BIND_COLOR_BLEND:
+        case XGL_STATE_BIND_DEPTH_STENCIL:
+        case XGL_STATE_BIND_RASTER:
+        case XGL_STATE_BIND_VIEWPORT:
             return 1;
         default:
             return 0;
@@ -688,161 +359,14 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
 {
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    switch ((XGL_OBJECT_INFO_TYPE)input_value)
     {
-        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
-        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
-        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
-        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
-        case XGL_IMAGE_CREATE_SPARSE_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
-{
-    switch ((XGL_TEX_ADDRESS)input_value)
-    {
-        case XGL_TEX_ADDRESS_CLAMP:
-        case XGL_TEX_ADDRESS_CLAMP_BORDER:
-        case XGL_TEX_ADDRESS_MIRROR:
-        case XGL_TEX_ADDRESS_MIRROR_ONCE:
-        case XGL_TEX_ADDRESS_WRAP:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
-    switch ((XGL_QUEUE_FLAGS)input_value)
-    {
-        case XGL_QUEUE_COMPUTE_BIT:
-        case XGL_QUEUE_DMA_BIT:
-        case XGL_QUEUE_EXTENDED_BIT:
-        case XGL_QUEUE_GRAPHICS_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
-    switch ((XGL_QUERY_TYPE)input_value)
-    {
-        case XGL_QUERY_OCCLUSION:
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
-    switch ((XGL_IMAGE_LAYOUT)input_value)
-    {
-        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_GENERAL:
-        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
-    {
-        case XGL_QUERY_IMPRECISE_DATA_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
-{
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
-    {
-        case XGL_SHADER_STAGE_COMPUTE:
-        case XGL_SHADER_STAGE_FRAGMENT:
-        case XGL_SHADER_STAGE_GEOMETRY:
-        case XGL_SHADER_STAGE_TESS_CONTROL:
-        case XGL_SHADER_STAGE_TESS_EVALUATION:
-        case XGL_SHADER_STAGE_VERTEX:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
-    switch ((XGL_COORDINATE_ORIGIN)input_value)
-    {
-        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
-        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
-    switch ((XGL_VALIDATION_LEVEL)input_value)
-    {
-        case XGL_VALIDATION_LEVEL_0:
-        case XGL_VALIDATION_LEVEL_1:
-        case XGL_VALIDATION_LEVEL_2:
-        case XGL_VALIDATION_LEVEL_3:
-        case XGL_VALIDATION_LEVEL_4:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
-    {
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
             return 1;
         default:
             return 0;
@@ -863,69 +387,6 @@
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
-    {
-        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
-        case XGL_BUFFER_CREATE_SPARSE_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
-    switch ((XGL_SET_EVENT)input_value)
-    {
-        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
-        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
-        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
-        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
-        case XGL_SET_EVENT_TOP_OF_PIPE:
-        case XGL_SET_EVENT_TRANSFER_COMPLETE:
-        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
-{
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
-    {
-        case XGL_PIPELINE_BIND_POINT_COMPUTE:
-        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
-    switch ((XGL_COMPARE_FUNC)input_value)
-    {
-        case XGL_COMPARE_ALWAYS:
-        case XGL_COMPARE_EQUAL:
-        case XGL_COMPARE_GREATER:
-        case XGL_COMPARE_GREATER_EQUAL:
-        case XGL_COMPARE_LESS:
-        case XGL_COMPARE_LESS_EQUAL:
-        case XGL_COMPARE_NEVER:
-        case XGL_COMPARE_NOT_EQUAL:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
 static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
 {
     switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
@@ -955,13 +416,176 @@
 }
 
 
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_FILL_MODE)input_value)
+    switch ((XGL_TEX_ADDRESS)input_value)
     {
-        case XGL_FILL_POINTS:
-        case XGL_FILL_SOLID:
-        case XGL_FILL_WIREFRAME:
+        case XGL_TEX_ADDRESS_CLAMP:
+        case XGL_TEX_ADDRESS_CLAMP_BORDER:
+        case XGL_TEX_ADDRESS_MIRROR:
+        case XGL_TEX_ADDRESS_MIRROR_ONCE:
+        case XGL_TEX_ADDRESS_WRAP:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+    {
+        case XGL_TOPOLOGY_LINE_LIST:
+        case XGL_TOPOLOGY_LINE_LIST_ADJ:
+        case XGL_TOPOLOGY_LINE_STRIP:
+        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+        case XGL_TOPOLOGY_PATCH:
+        case XGL_TOPOLOGY_POINT_LIST:
+        case XGL_TOPOLOGY_QUAD_LIST:
+        case XGL_TOPOLOGY_QUAD_STRIP:
+        case XGL_TOPOLOGY_RECT_LIST:
+        case XGL_TOPOLOGY_TRIANGLE_LIST:
+        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+        case XGL_TOPOLOGY_TRIANGLE_STRIP:
+        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    {
+        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+    switch ((XGL_STENCIL_OP)input_value)
+    {
+        case XGL_STENCIL_OP_DEC_CLAMP:
+        case XGL_STENCIL_OP_DEC_WRAP:
+        case XGL_STENCIL_OP_INC_CLAMP:
+        case XGL_STENCIL_OP_INC_WRAP:
+        case XGL_STENCIL_OP_INVERT:
+        case XGL_STENCIL_OP_KEEP:
+        case XGL_STENCIL_OP_REPLACE:
+        case XGL_STENCIL_OP_ZERO:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    {
+        case XGL_BUFFER_VIEW_RAW:
+        case XGL_BUFFER_VIEW_STRUCTURED:
+        case XGL_BUFFER_VIEW_TYPED:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    {
+        case XGL_GPU_TYPE_DISCRETE:
+        case XGL_GPU_TYPE_INTEGRATED:
+        case XGL_GPU_TYPE_OTHER:
+        case XGL_GPU_TYPE_VIRTUAL:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    {
+        case XGL_PROVOKING_VERTEX_FIRST:
+        case XGL_PROVOKING_VERTEX_LAST:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+{
+    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+    {
+        case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+        case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+        case XGL_FORMAT_CONVERSION_BIT:
+        case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+        case XGL_FORMAT_IMAGE_COPY_BIT:
+        case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+        case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+        case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+        case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+        case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+    switch ((XGL_COORDINATE_ORIGIN)input_value)
+    {
+        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+    switch ((XGL_MEMORY_PRIORITY)input_value)
+    {
+        case XGL_MEMORY_PRIORITY_HIGH:
+        case XGL_MEMORY_PRIORITY_LOW:
+        case XGL_MEMORY_PRIORITY_NORMAL:
+        case XGL_MEMORY_PRIORITY_UNUSED:
+        case XGL_MEMORY_PRIORITY_VERY_HIGH:
+        case XGL_MEMORY_PRIORITY_VERY_LOW:
             return 1;
         default:
             return 0;
@@ -987,6 +611,432 @@
 }
 
 
+static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
+{
+    switch ((XGL_BLEND)input_value)
+    {
+        case XGL_BLEND_CONSTANT_ALPHA:
+        case XGL_BLEND_CONSTANT_COLOR:
+        case XGL_BLEND_DEST_ALPHA:
+        case XGL_BLEND_DEST_COLOR:
+        case XGL_BLEND_ONE:
+        case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+        case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+        case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+        case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+        case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+        case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+        case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+        case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+        case XGL_BLEND_SRC1_ALPHA:
+        case XGL_BLEND_SRC1_COLOR:
+        case XGL_BLEND_SRC_ALPHA:
+        case XGL_BLEND_SRC_ALPHA_SATURATE:
+        case XGL_BLEND_SRC_COLOR:
+        case XGL_BLEND_ZERO:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+{
+    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+    {
+        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+        case XGL_BUFFER_CREATE_SPARSE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+    switch ((XGL_FACE_ORIENTATION)input_value)
+    {
+        case XGL_FRONT_FACE_CCW:
+        case XGL_FRONT_FACE_CW:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    {
+        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+        case XGL_MEMORY_OUTPUT_COPY_BIT:
+        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+    switch ((XGL_IMAGE_TYPE)input_value)
+    {
+        case XGL_IMAGE_1D:
+        case XGL_IMAGE_2D:
+        case XGL_IMAGE_3D:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+    switch ((XGL_MEMORY_TYPE)input_value)
+    {
+        case XGL_MEMORY_TYPE_BUFFER:
+        case XGL_MEMORY_TYPE_IMAGE:
+        case XGL_MEMORY_TYPE_OTHER:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+{
+    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    {
+        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+    switch ((XGL_BLEND_FUNC)input_value)
+    {
+        case XGL_BLEND_FUNC_ADD:
+        case XGL_BLEND_FUNC_MAX:
+        case XGL_BLEND_FUNC_MIN:
+        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+        case XGL_BLEND_FUNC_SUBTRACT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+    switch ((XGL_FILL_MODE)input_value)
+    {
+        case XGL_FILL_POINTS:
+        case XGL_FILL_SOLID:
+        case XGL_FILL_WIREFRAME:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+{
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+    {
+        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    {
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+    switch ((XGL_QUEUE_TYPE)input_value)
+    {
+        case XGL_QUEUE_TYPE_COMPUTE:
+        case XGL_QUEUE_TYPE_DMA:
+        case XGL_QUEUE_TYPE_GRAPHICS:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    {
+        case XGL_DESCRIPTOR_TYPE_IMAGE:
+        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+        case XGL_DESCRIPTOR_TYPE_SAMPLER:
+        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+        case XGL_DESCRIPTOR_TYPE_TEXTURE:
+        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+    switch ((XGL_TEX_FILTER)input_value)
+    {
+        case XGL_TEX_FILTER_LINEAR:
+        case XGL_TEX_FILTER_NEAREST:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+    switch ((XGL_SET_EVENT)input_value)
+    {
+        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+        case XGL_SET_EVENT_TOP_OF_PIPE:
+        case XGL_SET_EVENT_TRANSFER_COMPLETE:
+        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    {
+        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+        case XGL_IMAGE_CREATE_SPARSE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+    switch ((XGL_COMPARE_FUNC)input_value)
+    {
+        case XGL_COMPARE_ALWAYS:
+        case XGL_COMPARE_EQUAL:
+        case XGL_COMPARE_GREATER:
+        case XGL_COMPARE_GREATER_EQUAL:
+        case XGL_COMPARE_LESS:
+        case XGL_COMPARE_LESS_EQUAL:
+        case XGL_COMPARE_NEVER:
+        case XGL_COMPARE_NOT_EQUAL:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+    switch ((XGL_IMAGE_LAYOUT)input_value)
+    {
+        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_GENERAL:
+        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+{
+    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    {
+        case XGL_SHADER_STAGE_FLAGS_ALL:
+        case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+        case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+        case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+        case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+        case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+        case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    {
+        case XGL_SHADER_STAGE_COMPUTE:
+        case XGL_SHADER_STAGE_FRAGMENT:
+        case XGL_SHADER_STAGE_GEOMETRY:
+        case XGL_SHADER_STAGE_TESS_CONTROL:
+        case XGL_SHADER_STAGE_TESS_EVALUATION:
+        case XGL_SHADER_STAGE_VERTEX:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    {
+        case XGL_CHANNEL_SWIZZLE_A:
+        case XGL_CHANNEL_SWIZZLE_B:
+        case XGL_CHANNEL_SWIZZLE_G:
+        case XGL_CHANNEL_SWIZZLE_ONE:
+        case XGL_CHANNEL_SWIZZLE_R:
+        case XGL_CHANNEL_SWIZZLE_ZERO:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+    switch ((XGL_INDEX_TYPE)input_value)
+    {
+        case XGL_INDEX_16:
+        case XGL_INDEX_32:
+        case XGL_INDEX_8:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    {
+        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    {
+        case XGL_BORDER_COLOR_OPAQUE_BLACK:
+        case XGL_BORDER_COLOR_OPAQUE_WHITE:
+        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+    switch ((XGL_CULL_MODE)input_value)
+    {
+        case XGL_CULL_BACK:
+        case XGL_CULL_FRONT:
+        case XGL_CULL_FRONT_AND_BACK:
+        case XGL_CULL_NONE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    {
+        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
 static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
 {
     switch ((XGL_FORMAT)input_value)
@@ -1165,12 +1215,13 @@
 }
 
 
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_TEX_MIPMAP_MODE)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-        case XGL_FRONT_FACE_CW:
+        case XGL_TEX_MIPMAP_BASE:
+        case XGL_TEX_MIPMAP_LINEAR:
+        case XGL_TEX_MIPMAP_NEAREST:
             return 1;
         default:
             return 0;
@@ -1178,13 +1229,14 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_QUEUE_FLAGS)input_value)
     {
-        case XGL_IMAGE_1D:
-        case XGL_IMAGE_2D:
-        case XGL_IMAGE_3D:
+        case XGL_QUEUE_COMPUTE_BIT:
+        case XGL_QUEUE_DMA_BIT:
+        case XGL_QUEUE_EXTENDED_BIT:
+        case XGL_QUEUE_GRAPHICS_BIT:
             return 1;
         default:
             return 0;
@@ -1192,13 +1244,26 @@
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
 {
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    switch ((XGL_LOGIC_OP)input_value)
     {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+        case XGL_LOGIC_OP_AND:
+        case XGL_LOGIC_OP_AND_INVERTED:
+        case XGL_LOGIC_OP_AND_REVERSE:
+        case XGL_LOGIC_OP_CLEAR:
+        case XGL_LOGIC_OP_COPY:
+        case XGL_LOGIC_OP_COPY_INVERTED:
+        case XGL_LOGIC_OP_EQUIV:
+        case XGL_LOGIC_OP_INVERT:
+        case XGL_LOGIC_OP_NAND:
+        case XGL_LOGIC_OP_NOOP:
+        case XGL_LOGIC_OP_NOR:
+        case XGL_LOGIC_OP_OR:
+        case XGL_LOGIC_OP_OR_INVERTED:
+        case XGL_LOGIC_OP_OR_REVERSE:
+        case XGL_LOGIC_OP_SET:
+        case XGL_LOGIC_OP_XOR:
             return 1;
         default:
             return 0;
@@ -1206,16 +1271,15 @@
 }
 
 
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
 {
-    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    switch ((XGL_VALIDATION_LEVEL)input_value)
     {
-        case XGL_CHANNEL_SWIZZLE_A:
-        case XGL_CHANNEL_SWIZZLE_B:
-        case XGL_CHANNEL_SWIZZLE_G:
-        case XGL_CHANNEL_SWIZZLE_ONE:
-        case XGL_CHANNEL_SWIZZLE_R:
-        case XGL_CHANNEL_SWIZZLE_ZERO:
+        case XGL_VALIDATION_LEVEL_0:
+        case XGL_VALIDATION_LEVEL_1:
+        case XGL_VALIDATION_LEVEL_2:
+        case XGL_VALIDATION_LEVEL_3:
+        case XGL_VALIDATION_LEVEL_4:
             return 1;
         default:
             return 0;
@@ -1223,17 +1287,20 @@
 }
 
 
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
 {
-    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
     {
-        case XGL_SHADER_STAGE_FLAGS_ALL:
-        case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
-        case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
-        case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
-        case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
-        case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
-        case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+        case XGL_IMAGE_USAGE_GENERAL:
+        case XGL_IMAGE_USAGE_IMAGE_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+        case XGL_IMAGE_USAGE_TEXTURE_BIT:
+        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
             return 1;
         default:
             return 0;
@@ -1241,13 +1308,15 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
 {
-    switch ((XGL_IMAGE_ASPECT)input_value)
+    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
     {
-        case XGL_IMAGE_ASPECT_COLOR:
-        case XGL_IMAGE_ASPECT_DEPTH:
-        case XGL_IMAGE_ASPECT_STENCIL:
+        case XGL_SYSTEM_ALLOC_API_OBJECT:
+        case XGL_SYSTEM_ALLOC_DEBUG:
+        case XGL_SYSTEM_ALLOC_INTERNAL:
+        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
             return 1;
         default:
             return 0;
@@ -1255,36 +1324,17 @@
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
     {
-        case XGL_BUFFER_USAGE_GENERAL:
-        case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
-        case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
-        case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
-        case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
-        case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
-        case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
-        case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
-        case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
-        case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
-        case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
-    {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
             return 1;
         default:
             return 0;
@@ -1311,53 +1361,3 @@
     }
 }
 
-
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
-    switch ((XGL_INDEX_TYPE)input_value)
-    {
-        case XGL_INDEX_16:
-        case XGL_INDEX_32:
-        case XGL_INDEX_8:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
-    {
-        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
-{
-    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
-    {
-        case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
-        case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
-        case XGL_FORMAT_CONVERSION_BIT:
-        case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
-        case XGL_FORMAT_IMAGE_COPY_BIT:
-        case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
-        case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
-        case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
-        case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
-        case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp
index c05acdd..c3c1cdb 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp
@@ -27,7 +27,7 @@
 
 extern "C"
 {
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_packet_id.h"
 }
 
 ApiReplay* g_pReplayer = NULL;
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
index 5de203d..7cc11d7 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
@@ -11,26 +11,26 @@
 
 add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl.c
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext.c
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg.c
-                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h
+                          ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_struct_size_helper.h
                           ${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-trace-h > glvtrace_xgl_xgl.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-trace-c > glvtrace_xgl_xgl.c
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-h > glvtrace_xgl_xglwsix11ext.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-c > glvtrace_xgl_xglwsix11ext.c
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-h > glvtrace_xgl_xgldbg.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-c > glvtrace_xgl_xgldbg.c
-        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h
+        COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_struct_wrappers ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen
         COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen
                    DEPENDS ${SRC_DIR}/../../../xgl_helper.py
@@ -48,13 +48,13 @@
 set_source_files_properties( ${SRC_LIST} PROPERTIES LANGUAGE C)
 
 set (HDR_LIST
-    codegen/glvtrace_xgl_packet_id.h
+    codegen/glv_vk_packet_id.h
     codegen/glvtrace_xgl_xgl.h
-    codegen/glvtrace_xgl_xgl_structs.h
+    codegen/glv_vk_vk_structs.h
     codegen/glvtrace_xgl_xgldbg.h
-    codegen/glvtrace_xgl_xgldbg_structs.h
+    codegen/glv_vk_vkdbg_structs.h
     codegen/glvtrace_xgl_xglwsix11ext.h
-    codegen/glvtrace_xgl_xglwsix11ext_structs.h
+    codegen/glv_vk_vkwsix11ext_structs.h
     codegen/xgl_struct_size_helper.h
     codegen/xgl_enum_string_helper.h
 )
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h
similarity index 99%
copy from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
copy to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h
index d1dded3..d774f98 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h
@@ -29,9 +29,9 @@
 #include "glv_trace_packet_utils.h"
 #include "glv_trace_packet_identifiers.h"
 #include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_vkwsix11ext_structs.h"
 #include "xgl_enum_string_helper.h"
 #if defined(WIN32)
 #define snprintf _snprintf
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vk_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl_structs.h
rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vk_structs.h
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkdbg_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg_structs.h
rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkdbg_structs.h
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkwsix11ext_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h
rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkwsix11ext_structs.h
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h
deleted file mode 100644
index d1dded3..0000000
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h
+++ /dev/null
@@ -1,1475 +0,0 @@
-/* THIS FILE IS GENERATED.  DO NOT EDIT. */
-
-/*
- * XGL
- *
- * Copyright (C) 2014 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#pragma once
-
-#include "glv_trace_packet_utils.h"
-#include "glv_trace_packet_identifiers.h"
-#include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
-#include "xgl_enum_string_helper.h"
-#if defined(WIN32)
-#define snprintf _snprintf
-#endif
-#define SEND_ENTRYPOINT_ID(entrypoint) ;
-//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\n");
-
-#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;
-//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);
-
-#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \
-    pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);
-
-#define FINISH_TRACE_PACKET() \
-    glv_finalize_trace_packet(pHeader); \
-    glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \
-    glv_delete_trace_packet(&pHeader);
-
-enum GLV_TRACE_PACKET_ID_XGL
-{
-    GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,
-    GLV_TPI_XGL_xglCreateInstance,
-    GLV_TPI_XGL_xglDestroyInstance,
-    GLV_TPI_XGL_xglEnumerateGpus,
-    GLV_TPI_XGL_xglGetGpuInfo,
-    GLV_TPI_XGL_xglGetProcAddr,
-    GLV_TPI_XGL_xglCreateDevice,
-    GLV_TPI_XGL_xglDestroyDevice,
-    GLV_TPI_XGL_xglGetExtensionSupport,
-    GLV_TPI_XGL_xglEnumerateLayers,
-    GLV_TPI_XGL_xglGetDeviceQueue,
-    GLV_TPI_XGL_xglQueueSubmit,
-    GLV_TPI_XGL_xglQueueSetGlobalMemReferences,
-    GLV_TPI_XGL_xglQueueWaitIdle,
-    GLV_TPI_XGL_xglDeviceWaitIdle,
-    GLV_TPI_XGL_xglAllocMemory,
-    GLV_TPI_XGL_xglFreeMemory,
-    GLV_TPI_XGL_xglSetMemoryPriority,
-    GLV_TPI_XGL_xglMapMemory,
-    GLV_TPI_XGL_xglUnmapMemory,
-    GLV_TPI_XGL_xglPinSystemMemory,
-    GLV_TPI_XGL_xglGetMultiGpuCompatibility,
-    GLV_TPI_XGL_xglOpenSharedMemory,
-    GLV_TPI_XGL_xglOpenSharedQueueSemaphore,
-    GLV_TPI_XGL_xglOpenPeerMemory,
-    GLV_TPI_XGL_xglOpenPeerImage,
-    GLV_TPI_XGL_xglDestroyObject,
-    GLV_TPI_XGL_xglGetObjectInfo,
-    GLV_TPI_XGL_xglBindObjectMemory,
-    GLV_TPI_XGL_xglBindObjectMemoryRange,
-    GLV_TPI_XGL_xglBindImageMemoryRange,
-    GLV_TPI_XGL_xglCreateFence,
-    GLV_TPI_XGL_xglGetFenceStatus,
-    GLV_TPI_XGL_xglWaitForFences,
-    GLV_TPI_XGL_xglCreateQueueSemaphore,
-    GLV_TPI_XGL_xglSignalQueueSemaphore,
-    GLV_TPI_XGL_xglWaitQueueSemaphore,
-    GLV_TPI_XGL_xglCreateEvent,
-    GLV_TPI_XGL_xglGetEventStatus,
-    GLV_TPI_XGL_xglSetEvent,
-    GLV_TPI_XGL_xglResetEvent,
-    GLV_TPI_XGL_xglCreateQueryPool,
-    GLV_TPI_XGL_xglGetQueryPoolResults,
-    GLV_TPI_XGL_xglGetFormatInfo,
-    GLV_TPI_XGL_xglCreateBuffer,
-    GLV_TPI_XGL_xglCreateBufferView,
-    GLV_TPI_XGL_xglCreateImage,
-    GLV_TPI_XGL_xglSetFastClearColor,
-    GLV_TPI_XGL_xglSetFastClearDepth,
-    GLV_TPI_XGL_xglGetImageSubresourceInfo,
-    GLV_TPI_XGL_xglCreateImageView,
-    GLV_TPI_XGL_xglCreateColorAttachmentView,
-    GLV_TPI_XGL_xglCreateDepthStencilView,
-    GLV_TPI_XGL_xglCreateShader,
-    GLV_TPI_XGL_xglCreateGraphicsPipeline,
-    GLV_TPI_XGL_xglCreateComputePipeline,
-    GLV_TPI_XGL_xglStorePipeline,
-    GLV_TPI_XGL_xglLoadPipeline,
-    GLV_TPI_XGL_xglCreatePipelineDelta,
-    GLV_TPI_XGL_xglCreateSampler,
-    GLV_TPI_XGL_xglCreateDescriptorSetLayout,
-    GLV_TPI_XGL_xglBeginDescriptorRegionUpdate,
-    GLV_TPI_XGL_xglEndDescriptorRegionUpdate,
-    GLV_TPI_XGL_xglCreateDescriptorRegion,
-    GLV_TPI_XGL_xglClearDescriptorRegion,
-    GLV_TPI_XGL_xglAllocDescriptorSets,
-    GLV_TPI_XGL_xglClearDescriptorSets,
-    GLV_TPI_XGL_xglUpdateDescriptors,
-    GLV_TPI_XGL_xglCreateDynamicViewportState,
-    GLV_TPI_XGL_xglCreateDynamicRasterState,
-    GLV_TPI_XGL_xglCreateDynamicColorBlendState,
-    GLV_TPI_XGL_xglCreateDynamicDepthStencilState,
-    GLV_TPI_XGL_xglCreateCommandBuffer,
-    GLV_TPI_XGL_xglBeginCommandBuffer,
-    GLV_TPI_XGL_xglEndCommandBuffer,
-    GLV_TPI_XGL_xglResetCommandBuffer,
-    GLV_TPI_XGL_xglCmdBindPipeline,
-    GLV_TPI_XGL_xglCmdBindPipelineDelta,
-    GLV_TPI_XGL_xglCmdBindDynamicStateObject,
-    GLV_TPI_XGL_xglCmdBindDescriptorSet,
-    GLV_TPI_XGL_xglCmdBindVertexBuffer,
-    GLV_TPI_XGL_xglCmdBindIndexBuffer,
-    GLV_TPI_XGL_xglCmdDraw,
-    GLV_TPI_XGL_xglCmdDrawIndexed,
-    GLV_TPI_XGL_xglCmdDrawIndirect,
-    GLV_TPI_XGL_xglCmdDrawIndexedIndirect,
-    GLV_TPI_XGL_xglCmdDispatch,
-    GLV_TPI_XGL_xglCmdDispatchIndirect,
-    GLV_TPI_XGL_xglCmdCopyBuffer,
-    GLV_TPI_XGL_xglCmdCopyImage,
-    GLV_TPI_XGL_xglCmdCopyBufferToImage,
-    GLV_TPI_XGL_xglCmdCopyImageToBuffer,
-    GLV_TPI_XGL_xglCmdCloneImageData,
-    GLV_TPI_XGL_xglCmdUpdateBuffer,
-    GLV_TPI_XGL_xglCmdFillBuffer,
-    GLV_TPI_XGL_xglCmdClearColorImage,
-    GLV_TPI_XGL_xglCmdClearColorImageRaw,
-    GLV_TPI_XGL_xglCmdClearDepthStencil,
-    GLV_TPI_XGL_xglCmdResolveImage,
-    GLV_TPI_XGL_xglCmdSetEvent,
-    GLV_TPI_XGL_xglCmdResetEvent,
-    GLV_TPI_XGL_xglCmdWaitEvents,
-    GLV_TPI_XGL_xglCmdPipelineBarrier,
-    GLV_TPI_XGL_xglCmdBeginQuery,
-    GLV_TPI_XGL_xglCmdEndQuery,
-    GLV_TPI_XGL_xglCmdResetQueryPool,
-    GLV_TPI_XGL_xglCmdWriteTimestamp,
-    GLV_TPI_XGL_xglCmdInitAtomicCounters,
-    GLV_TPI_XGL_xglCmdLoadAtomicCounters,
-    GLV_TPI_XGL_xglCmdSaveAtomicCounters,
-    GLV_TPI_XGL_xglCreateFramebuffer,
-    GLV_TPI_XGL_xglCreateRenderPass,
-    GLV_TPI_XGL_xglCmdBeginRenderPass,
-    GLV_TPI_XGL_xglCmdEndRenderPass,
-    GLV_TPI_XGL_xglDbgSetValidationLevel,
-    GLV_TPI_XGL_xglDbgRegisterMsgCallback,
-    GLV_TPI_XGL_xglDbgUnregisterMsgCallback,
-    GLV_TPI_XGL_xglDbgSetMessageFilter,
-    GLV_TPI_XGL_xglDbgSetObjectTag,
-    GLV_TPI_XGL_xglDbgSetGlobalOption,
-    GLV_TPI_XGL_xglDbgSetDeviceOption,
-    GLV_TPI_XGL_xglCmdDbgMarkerBegin,
-    GLV_TPI_XGL_xglCmdDbgMarkerEnd,
-    GLV_TPI_XGL_xglWsiX11AssociateConnection,
-    GLV_TPI_XGL_xglWsiX11GetMSC,
-    GLV_TPI_XGL_xglWsiX11CreatePresentableImage,
-    GLV_TPI_XGL_xglWsiX11QueuePresent,
-};
-
-static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)
-{
-    static char str[1024];
-    switch(id) {
-    case GLV_TPI_XGL_xglApiVersion:
-    {
-        struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);
-        snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateInstance:
-    {
-        struct_xglCreateInstance* pPacket = (struct_xglCreateInstance*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateInstance(pAppInfo = %p, pAllocCb = %p, pInstance = %p)", (void*)(pPacket->pAppInfo), (void*)(pPacket->pAllocCb), (void*)pPacket->pInstance);
-        return str;
-    }
-    case GLV_TPI_XGL_xglDestroyInstance:
-    {
-        struct_xglDestroyInstance* pPacket = (struct_xglDestroyInstance*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDestroyInstance(instance = %p)", (void*)(pPacket->instance));
-        return str;
-    }
-    case GLV_TPI_XGL_xglEnumerateGpus:
-    {
-        struct_xglEnumerateGpus* pPacket = (struct_xglEnumerateGpus*)(pHeader->pBody);
-        snprintf(str, 1024, "xglEnumerateGpus(instance = %p, maxGpus = %i, *pGpuCount = %i, pGpus = %p)", (void*)(pPacket->instance), pPacket->maxGpus, (pPacket->pGpuCount == NULL) ? 0 : *(pPacket->pGpuCount), (void*)(pPacket->pGpus));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetGpuInfo:
-    {
-        struct_xglGetGpuInfo* pPacket = (struct_xglGetGpuInfo*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetGpuInfo(gpu = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->gpu), string_XGL_PHYSICAL_GPU_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetProcAddr:
-    {
-        struct_xglGetProcAddr* pPacket = (struct_xglGetProcAddr*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetProcAddr(gpu = %p, pName = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pName));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDevice:
-    {
-        struct_xglCreateDevice* pPacket = (struct_xglCreateDevice*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDevice(gpu = %p, pCreateInfo = %p, pDevice = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pCreateInfo), (void*)pPacket->pDevice);
-        return str;
-    }
-    case GLV_TPI_XGL_xglDestroyDevice:
-    {
-        struct_xglDestroyDevice* pPacket = (struct_xglDestroyDevice*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDestroyDevice(device = %p)", (void*)(pPacket->device));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetExtensionSupport:
-    {
-        struct_xglGetExtensionSupport* pPacket = (struct_xglGetExtensionSupport*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetExtensionSupport(gpu = %p, pExtName = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pExtName));
-        return str;
-    }
-    case GLV_TPI_XGL_xglEnumerateLayers:
-    {
-        struct_xglEnumerateLayers* pPacket = (struct_xglEnumerateLayers*)(pHeader->pBody);
-        snprintf(str, 1024, "xglEnumerateLayers(gpu = %p, maxLayerCount = %zu, maxStringSize = %zu, *pOutLayerCount = %zu, pOutLayers = %p, pReserved = %p)", (void*)(pPacket->gpu), pPacket->maxLayerCount, pPacket->maxStringSize, (pPacket->pOutLayerCount == NULL) ? 0 : *(pPacket->pOutLayerCount), (void*)(pPacket->pOutLayers), (void*)(pPacket->pReserved));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetDeviceQueue:
-    {
-        struct_xglGetDeviceQueue* pPacket = (struct_xglGetDeviceQueue*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetDeviceQueue(device = %p, queueType = %s, queueIndex = %i, pQueue = %p)", (void*)(pPacket->device), string_XGL_QUEUE_TYPE(pPacket->queueType), pPacket->queueIndex, (void*)(pPacket->pQueue));
-        return str;
-    }
-    case GLV_TPI_XGL_xglQueueSubmit:
-    {
-        struct_xglQueueSubmit* pPacket = (struct_xglQueueSubmit*)(pHeader->pBody);
-        snprintf(str, 1024, "xglQueueSubmit(queue = %p, cmdBufferCount = %i, pCmdBuffers = %p, memRefCount = %i, pMemRefs = %p, fence = %p)", (void*)(pPacket->queue), pPacket->cmdBufferCount, (void*)(pPacket->pCmdBuffers), pPacket->memRefCount, (void*)(pPacket->pMemRefs), (void*)(pPacket->fence));
-        return str;
-    }
-    case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
-    {
-        struct_xglQueueSetGlobalMemReferences* pPacket = (struct_xglQueueSetGlobalMemReferences*)(pHeader->pBody);
-        snprintf(str, 1024, "xglQueueSetGlobalMemReferences(queue = %p, memRefCount = %i, pMemRefs = %p)", (void*)(pPacket->queue), pPacket->memRefCount, (void*)(pPacket->pMemRefs));
-        return str;
-    }
-    case GLV_TPI_XGL_xglQueueWaitIdle:
-    {
-        struct_xglQueueWaitIdle* pPacket = (struct_xglQueueWaitIdle*)(pHeader->pBody);
-        snprintf(str, 1024, "xglQueueWaitIdle(queue = %p)", (void*)(pPacket->queue));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDeviceWaitIdle:
-    {
-        struct_xglDeviceWaitIdle* pPacket = (struct_xglDeviceWaitIdle*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDeviceWaitIdle(device = %p)", (void*)(pPacket->device));
-        return str;
-    }
-    case GLV_TPI_XGL_xglAllocMemory:
-    {
-        struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglAllocMemory(device = %p, pAllocInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pAllocInfo), (void*)pPacket->pMem);
-        return str;
-    }
-    case GLV_TPI_XGL_xglFreeMemory:
-    {
-        struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglFreeMemory(mem = %p)", (void*)(pPacket->mem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglSetMemoryPriority:
-    {
-        struct_xglSetMemoryPriority* pPacket = (struct_xglSetMemoryPriority*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSetMemoryPriority(mem = %p, priority = %p)", (void*)(pPacket->mem), (void*)(pPacket->priority));
-        return str;
-    }
-    case GLV_TPI_XGL_xglMapMemory:
-    {
-        struct_xglMapMemory* pPacket = (struct_xglMapMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglMapMemory(mem = %p, flags = %i, ppData = %p)", (void*)(pPacket->mem), pPacket->flags, (void*)pPacket->ppData);
-        return str;
-    }
-    case GLV_TPI_XGL_xglUnmapMemory:
-    {
-        struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglUnmapMemory(mem = %p)", (void*)(pPacket->mem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglPinSystemMemory:
-    {
-        struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglPinSystemMemory(device = %p, pSysMem = %p, memSize = %zu, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pSysMem), pPacket->memSize, (void*)(pPacket->pMem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
-    {
-        struct_xglGetMultiGpuCompatibility* pPacket = (struct_xglGetMultiGpuCompatibility*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetMultiGpuCompatibility(gpu0 = %p, gpu1 = %p, pInfo = %p)", (void*)(pPacket->gpu0), (void*)(pPacket->gpu1), (void*)(pPacket->pInfo));
-        return str;
-    }
-    case GLV_TPI_XGL_xglOpenSharedMemory:
-    {
-        struct_xglOpenSharedMemory* pPacket = (struct_xglOpenSharedMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglOpenSharedMemory(device = %p, pOpenInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pMem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
-    {
-        struct_xglOpenSharedQueueSemaphore* pPacket = (struct_xglOpenSharedQueueSemaphore*)(pHeader->pBody);
-        snprintf(str, 1024, "xglOpenSharedQueueSemaphore(device = %p, pOpenInfo = %p, pSemaphore = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pSemaphore));
-        return str;
-    }
-    case GLV_TPI_XGL_xglOpenPeerMemory:
-    {
-        struct_xglOpenPeerMemory* pPacket = (struct_xglOpenPeerMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglOpenPeerMemory(device = %p, pOpenInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pMem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglOpenPeerImage:
-    {
-        struct_xglOpenPeerImage* pPacket = (struct_xglOpenPeerImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglOpenPeerImage(device = %p, pOpenInfo = %p, pImage = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pImage), (void*)(pPacket->pMem));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDestroyObject:
-    {
-        struct_xglDestroyObject* pPacket = (struct_xglDestroyObject*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDestroyObject(object = %p)", (void*)(pPacket->object));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetObjectInfo:
-    {
-        struct_xglGetObjectInfo* pPacket = (struct_xglGetObjectInfo*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetObjectInfo(object = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->object), string_XGL_OBJECT_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglBindObjectMemory:
-    {
-        struct_xglBindObjectMemory* pPacket = (struct_xglBindObjectMemory*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBindObjectMemory(object = %p, allocationIdx = %i, mem = %p, offset = %p)", (void*)(pPacket->object), pPacket->allocationIdx, (void*)(pPacket->mem), (void*)(pPacket->offset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglBindObjectMemoryRange:
-    {
-        struct_xglBindObjectMemoryRange* pPacket = (struct_xglBindObjectMemoryRange*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBindObjectMemoryRange(object = %p, allocationIdx = %i, rangeOffset = %p, rangeSize = %p, mem = %p, memOffset = %p)", (void*)(pPacket->object), pPacket->allocationIdx, (void*)(pPacket->rangeOffset), (void*)(pPacket->rangeSize), (void*)(pPacket->mem), (void*)(pPacket->memOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglBindImageMemoryRange:
-    {
-        struct_xglBindImageMemoryRange* pPacket = (struct_xglBindImageMemoryRange*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBindImageMemoryRange(image = %p, allocationIdx = %i, bindInfo = %p, mem = %p, memOffset = %p)", (void*)(pPacket->image), pPacket->allocationIdx, (void*)(pPacket->bindInfo), (void*)(pPacket->mem), (void*)(pPacket->memOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateFence:
-    {
-        struct_xglCreateFence* pPacket = (struct_xglCreateFence*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateFence(device = %p, pCreateInfo = %p, pFence = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pFence);
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetFenceStatus:
-    {
-        struct_xglGetFenceStatus* pPacket = (struct_xglGetFenceStatus*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetFenceStatus(fence = %p)", (void*)(pPacket->fence));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWaitForFences:
-    {
-        struct_xglWaitForFences* pPacket = (struct_xglWaitForFences*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWaitForFences(device = %p, fenceCount = %i, pFences = %p, waitAll = %u, timeout = %lu)", (void*)(pPacket->device), pPacket->fenceCount, (void*)(pPacket->pFences), pPacket->waitAll, pPacket->timeout);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateQueueSemaphore:
-    {
-        struct_xglCreateQueueSemaphore* pPacket = (struct_xglCreateQueueSemaphore*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateQueueSemaphore(device = %p, pCreateInfo = %p, pSemaphore = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pSemaphore);
-        return str;
-    }
-    case GLV_TPI_XGL_xglSignalQueueSemaphore:
-    {
-        struct_xglSignalQueueSemaphore* pPacket = (struct_xglSignalQueueSemaphore*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSignalQueueSemaphore(queue = %p, semaphore = %p)", (void*)(pPacket->queue), (void*)(pPacket->semaphore));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWaitQueueSemaphore:
-    {
-        struct_xglWaitQueueSemaphore* pPacket = (struct_xglWaitQueueSemaphore*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWaitQueueSemaphore(queue = %p, semaphore = %p)", (void*)(pPacket->queue), (void*)(pPacket->semaphore));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateEvent:
-    {
-        struct_xglCreateEvent* pPacket = (struct_xglCreateEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateEvent(device = %p, pCreateInfo = %p, pEvent = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pEvent);
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetEventStatus:
-    {
-        struct_xglGetEventStatus* pPacket = (struct_xglGetEventStatus*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetEventStatus(event = %p)", (void*)(pPacket->event));
-        return str;
-    }
-    case GLV_TPI_XGL_xglSetEvent:
-    {
-        struct_xglSetEvent* pPacket = (struct_xglSetEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSetEvent(event = %p)", (void*)(pPacket->event));
-        return str;
-    }
-    case GLV_TPI_XGL_xglResetEvent:
-    {
-        struct_xglResetEvent* pPacket = (struct_xglResetEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglResetEvent(event = %p)", (void*)(pPacket->event));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateQueryPool:
-    {
-        struct_xglCreateQueryPool* pPacket = (struct_xglCreateQueryPool*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateQueryPool(device = %p, pCreateInfo = %p, pQueryPool = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pQueryPool);
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetQueryPoolResults:
-    {
-        struct_xglGetQueryPoolResults* pPacket = (struct_xglGetQueryPoolResults*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetQueryPoolResults(queryPool = %p, startQuery = %i, queryCount = %i, *pDataSize = %zu, pData = %p)", (void*)(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount, (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetFormatInfo:
-    {
-        struct_xglGetFormatInfo* pPacket = (struct_xglGetFormatInfo*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetFormatInfo(device = %p, format = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->device), (void*)(pPacket->format), string_XGL_FORMAT_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateBuffer:
-    {
-        struct_xglCreateBuffer* pPacket = (struct_xglCreateBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateBuffer(device = %p, pCreateInfo = %p, pBuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pBuffer);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateBufferView:
-    {
-        struct_xglCreateBufferView* pPacket = (struct_xglCreateBufferView*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateBufferView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateImage:
-    {
-        struct_xglCreateImage* pPacket = (struct_xglCreateImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateImage(device = %p, pCreateInfo = %p, pImage = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pImage);
-        return str;
-    }
-    case GLV_TPI_XGL_xglSetFastClearColor:
-    {
-        struct_xglSetFastClearColor* pPacket = (struct_xglSetFastClearColor*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSetFastClearColor(image = %p, color = [%f, %f, %f, %f])", (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3]);
-        return str;
-    }
-    case GLV_TPI_XGL_xglSetFastClearDepth:
-    {
-        struct_xglSetFastClearDepth* pPacket = (struct_xglSetFastClearDepth*)(pHeader->pBody);
-        snprintf(str, 1024, "xglSetFastClearDepth(image = %p, depth = %f)", (void*)(pPacket->image), pPacket->depth);
-        return str;
-    }
-    case GLV_TPI_XGL_xglGetImageSubresourceInfo:
-    {
-        struct_xglGetImageSubresourceInfo* pPacket = (struct_xglGetImageSubresourceInfo*)(pHeader->pBody);
-        snprintf(str, 1024, "xglGetImageSubresourceInfo(image = %p, pSubresource = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->image), (void*)(pPacket->pSubresource), string_XGL_SUBRESOURCE_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateImageView:
-    {
-        struct_xglCreateImageView* pPacket = (struct_xglCreateImageView*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateImageView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateColorAttachmentView:
-    {
-        struct_xglCreateColorAttachmentView* pPacket = (struct_xglCreateColorAttachmentView*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateColorAttachmentView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDepthStencilView:
-    {
-        struct_xglCreateDepthStencilView* pPacket = (struct_xglCreateDepthStencilView*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDepthStencilView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateShader:
-    {
-        struct_xglCreateShader* pPacket = (struct_xglCreateShader*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateShader(device = %p, pCreateInfo = %p, pShader = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pShader);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateGraphicsPipeline:
-    {
-        struct_xglCreateGraphicsPipeline* pPacket = (struct_xglCreateGraphicsPipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateGraphicsPipeline(device = %p, pCreateInfo = %p, pPipeline = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pPipeline);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateComputePipeline:
-    {
-        struct_xglCreateComputePipeline* pPacket = (struct_xglCreateComputePipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateComputePipeline(device = %p, pCreateInfo = %p, pPipeline = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pPipeline);
-        return str;
-    }
-    case GLV_TPI_XGL_xglStorePipeline:
-    {
-        struct_xglStorePipeline* pPacket = (struct_xglStorePipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglStorePipeline(pipeline = %p, *pDataSize = %zu, pData = %p)", (void*)(pPacket->pipeline), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglLoadPipeline:
-    {
-        struct_xglLoadPipeline* pPacket = (struct_xglLoadPipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglLoadPipeline(device = %p, dataSize = %zu, pData = %p, pPipeline = %p)", (void*)(pPacket->device), pPacket->dataSize, (void*)(pPacket->pData), (void*)(pPacket->pPipeline));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreatePipelineDelta:
-    {
-        struct_xglCreatePipelineDelta* pPacket = (struct_xglCreatePipelineDelta*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreatePipelineDelta(device = %p, p1 = %p, p2 = %p, delta = %p)", (void*)(pPacket->device), (void*)(pPacket->p1), (void*)(pPacket->p2), (void*)pPacket->delta);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateSampler:
-    {
-        struct_xglCreateSampler* pPacket = (struct_xglCreateSampler*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateSampler(device = %p, pCreateInfo = %p, pSampler = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pSampler);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
-    {
-        struct_xglCreateDescriptorSetLayout* pPacket = (struct_xglCreateDescriptorSetLayout*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDescriptorSetLayout(device = %p, stageFlags = %i, *pSetBindPoints = %i, priorSetLayout = %p, pSetLayoutInfoList = %p, pSetLayout = %p)", (void*)(pPacket->device), pPacket->stageFlags, (pPacket->pSetBindPoints == NULL) ? 0 : *(pPacket->pSetBindPoints), (void*)(pPacket->priorSetLayout), (void*)(pPacket->pSetLayoutInfoList), (void*)pPacket->pSetLayout);
-        return str;
-    }
-    case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
-    {
-        struct_xglBeginDescriptorRegionUpdate* pPacket = (struct_xglBeginDescriptorRegionUpdate*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBeginDescriptorRegionUpdate(device = %p, updateMode = %p)", (void*)(pPacket->device), (void*)(pPacket->updateMode));
-        return str;
-    }
-    case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
-    {
-        struct_xglEndDescriptorRegionUpdate* pPacket = (struct_xglEndDescriptorRegionUpdate*)(pHeader->pBody);
-        snprintf(str, 1024, "xglEndDescriptorRegionUpdate(device = %p, cmd = %p)", (void*)(pPacket->device), (void*)(pPacket->cmd));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDescriptorRegion:
-    {
-        struct_xglCreateDescriptorRegion* pPacket = (struct_xglCreateDescriptorRegion*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDescriptorRegion(device = %p, regionUsage = %p, maxSets = %i, pCreateInfo = %p, pDescriptorRegion = %p)", (void*)(pPacket->device), (void*)(pPacket->regionUsage), pPacket->maxSets, (void*)(pPacket->pCreateInfo), (void*)pPacket->pDescriptorRegion);
-        return str;
-    }
-    case GLV_TPI_XGL_xglClearDescriptorRegion:
-    {
-        struct_xglClearDescriptorRegion* pPacket = (struct_xglClearDescriptorRegion*)(pHeader->pBody);
-        snprintf(str, 1024, "xglClearDescriptorRegion(descriptorRegion = %p)", (void*)(pPacket->descriptorRegion));
-        return str;
-    }
-    case GLV_TPI_XGL_xglAllocDescriptorSets:
-    {
-        struct_xglAllocDescriptorSets* pPacket = (struct_xglAllocDescriptorSets*)(pHeader->pBody);
-        snprintf(str, 1024, "xglAllocDescriptorSets(descriptorRegion = %p, setUsage = %p, count = %i, pSetLayouts = %p, pDescriptorSets = %p, *pCount = %i)", (void*)(pPacket->descriptorRegion), (void*)(pPacket->setUsage), pPacket->count, (void*)(pPacket->pSetLayouts), (void*)(pPacket->pDescriptorSets), (pPacket->pCount == NULL) ? 0 : *(pPacket->pCount));
-        return str;
-    }
-    case GLV_TPI_XGL_xglClearDescriptorSets:
-    {
-        struct_xglClearDescriptorSets* pPacket = (struct_xglClearDescriptorSets*)(pHeader->pBody);
-        snprintf(str, 1024, "xglClearDescriptorSets(descriptorRegion = %p, count = %i, pDescriptorSets = %p)", (void*)(pPacket->descriptorRegion), pPacket->count, (void*)(pPacket->pDescriptorSets));
-        return str;
-    }
-    case GLV_TPI_XGL_xglUpdateDescriptors:
-    {
-        struct_xglUpdateDescriptors* pPacket = (struct_xglUpdateDescriptors*)(pHeader->pBody);
-        snprintf(str, 1024, "xglUpdateDescriptors(descriptorSet = %p, pUpdateChain = %p)", (void*)(pPacket->descriptorSet), (void*)(pPacket->pUpdateChain));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDynamicViewportState:
-    {
-        struct_xglCreateDynamicViewportState* pPacket = (struct_xglCreateDynamicViewportState*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDynamicViewportState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDynamicRasterState:
-    {
-        struct_xglCreateDynamicRasterState* pPacket = (struct_xglCreateDynamicRasterState*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDynamicRasterState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
-    {
-        struct_xglCreateDynamicColorBlendState* pPacket = (struct_xglCreateDynamicColorBlendState*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDynamicColorBlendState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
-    {
-        struct_xglCreateDynamicDepthStencilState* pPacket = (struct_xglCreateDynamicDepthStencilState*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateDynamicDepthStencilState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateCommandBuffer:
-    {
-        struct_xglCreateCommandBuffer* pPacket = (struct_xglCreateCommandBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateCommandBuffer(device = %p, pCreateInfo = %p, pCmdBuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pCmdBuffer);
-        return str;
-    }
-    case GLV_TPI_XGL_xglBeginCommandBuffer:
-    {
-        struct_xglBeginCommandBuffer* pPacket = (struct_xglBeginCommandBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglBeginCommandBuffer(cmdBuffer = %p, pBeginInfo = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pBeginInfo));
-        return str;
-    }
-    case GLV_TPI_XGL_xglEndCommandBuffer:
-    {
-        struct_xglEndCommandBuffer* pPacket = (struct_xglEndCommandBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglEndCommandBuffer(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
-        return str;
-    }
-    case GLV_TPI_XGL_xglResetCommandBuffer:
-    {
-        struct_xglResetCommandBuffer* pPacket = (struct_xglResetCommandBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglResetCommandBuffer(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindPipeline:
-    {
-        struct_xglCmdBindPipeline* pPacket = (struct_xglCmdBindPipeline*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindPipeline(cmdBuffer = %p, pipelineBindPoint = %p, pipeline = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->pipeline));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindPipelineDelta:
-    {
-        struct_xglCmdBindPipelineDelta* pPacket = (struct_xglCmdBindPipelineDelta*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindPipelineDelta(cmdBuffer = %p, pipelineBindPoint = %p, delta = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->delta));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
-    {
-        struct_xglCmdBindDynamicStateObject* pPacket = (struct_xglCmdBindDynamicStateObject*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindDynamicStateObject(cmdBuffer = %p, stateBindPoint = %p, state = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->stateBindPoint), (void*)(pPacket->state));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindDescriptorSet:
-    {
-        struct_xglCmdBindDescriptorSet* pPacket = (struct_xglCmdBindDescriptorSet*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindDescriptorSet(cmdBuffer = %p, pipelineBindPoint = %p, descriptorSet = %p, *pUserData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->descriptorSet), (pPacket->pUserData == NULL) ? 0 : *(pPacket->pUserData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindVertexBuffer:
-    {
-        struct_xglCmdBindVertexBuffer* pPacket = (struct_xglCmdBindVertexBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindVertexBuffer(cmdBuffer = %p, buffer = %p, offset = %p, binding = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->binding);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBindIndexBuffer:
-    {
-        struct_xglCmdBindIndexBuffer* pPacket = (struct_xglCmdBindIndexBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBindIndexBuffer(cmdBuffer = %p, buffer = %p, offset = %p, indexType = %s)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), string_XGL_INDEX_TYPE(pPacket->indexType));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDraw:
-    {
-        struct_xglCmdDraw* pPacket = (struct_xglCmdDraw*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDraw(cmdBuffer = %p, firstVertex = %i, vertexCount = %i, firstInstance = %i, instanceCount = %i)", (void*)(pPacket->cmdBuffer), pPacket->firstVertex, pPacket->vertexCount, pPacket->firstInstance, pPacket->instanceCount);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDrawIndexed:
-    {
-        struct_xglCmdDrawIndexed* pPacket = (struct_xglCmdDrawIndexed*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDrawIndexed(cmdBuffer = %p, firstIndex = %i, indexCount = %i, vertexOffset = %i, firstInstance = %i, instanceCount = %i)", (void*)(pPacket->cmdBuffer), pPacket->firstIndex, pPacket->indexCount, pPacket->vertexOffset, pPacket->firstInstance, pPacket->instanceCount);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDrawIndirect:
-    {
-        struct_xglCmdDrawIndirect* pPacket = (struct_xglCmdDrawIndirect*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDrawIndirect(cmdBuffer = %p, buffer = %p, offset = %p, count = %i, stride = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->count, pPacket->stride);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
-    {
-        struct_xglCmdDrawIndexedIndirect* pPacket = (struct_xglCmdDrawIndexedIndirect*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDrawIndexedIndirect(cmdBuffer = %p, buffer = %p, offset = %p, count = %i, stride = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->count, pPacket->stride);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDispatch:
-    {
-        struct_xglCmdDispatch* pPacket = (struct_xglCmdDispatch*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDispatch(cmdBuffer = %p, x = %i, y = %i, z = %i)", (void*)(pPacket->cmdBuffer), pPacket->x, pPacket->y, pPacket->z);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDispatchIndirect:
-    {
-        struct_xglCmdDispatchIndirect* pPacket = (struct_xglCmdDispatchIndirect*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDispatchIndirect(cmdBuffer = %p, buffer = %p, offset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCopyBuffer:
-    {
-        struct_xglCmdCopyBuffer* pPacket = (struct_xglCmdCopyBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCopyBuffer(cmdBuffer = %p, srcBuffer = %p, destBuffer = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcBuffer), (void*)(pPacket->destBuffer), pPacket->regionCount, (void*)(pPacket->pRegions));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCopyImage:
-    {
-        struct_xglCmdCopyImage* pPacket = (struct_xglCmdCopyImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCopyImage(cmdBuffer = %p, srcImage = %p, destImage = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destImage), pPacket->regionCount, (void*)(pPacket->pRegions));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCopyBufferToImage:
-    {
-        struct_xglCmdCopyBufferToImage* pPacket = (struct_xglCmdCopyBufferToImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCopyBufferToImage(cmdBuffer = %p, srcBuffer = %p, destImage = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcBuffer), (void*)(pPacket->destImage), pPacket->regionCount, (void*)(pPacket->pRegions));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
-    {
-        struct_xglCmdCopyImageToBuffer* pPacket = (struct_xglCmdCopyImageToBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCopyImageToBuffer(cmdBuffer = %p, srcImage = %p, destBuffer = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destBuffer), pPacket->regionCount, (void*)(pPacket->pRegions));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdCloneImageData:
-    {
-        struct_xglCmdCloneImageData* pPacket = (struct_xglCmdCloneImageData*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdCloneImageData(cmdBuffer = %p, srcImage = %p, srcImageLayout = %p, destImage = %p, destImageLayout = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->srcImageLayout), (void*)(pPacket->destImage), (void*)(pPacket->destImageLayout));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdUpdateBuffer:
-    {
-        struct_xglCmdUpdateBuffer* pPacket = (struct_xglCmdUpdateBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdUpdateBuffer(cmdBuffer = %p, destBuffer = %p, destOffset = %p, dataSize = %p, *pData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset), (void*)(pPacket->dataSize), (pPacket->pData == NULL) ? 0 : *(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdFillBuffer:
-    {
-        struct_xglCmdFillBuffer* pPacket = (struct_xglCmdFillBuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdFillBuffer(cmdBuffer = %p, destBuffer = %p, destOffset = %p, fillSize = %p, data = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset), (void*)(pPacket->fillSize), pPacket->data);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdClearColorImage:
-    {
-        struct_xglCmdClearColorImage* pPacket = (struct_xglCmdClearColorImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdClearColorImage(cmdBuffer = %p, image = %p, color = [%f, %f, %f, %f], rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3], pPacket->rangeCount, (void*)(pPacket->pRanges));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdClearColorImageRaw:
-    {
-        struct_xglCmdClearColorImageRaw* pPacket = (struct_xglCmdClearColorImageRaw*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdClearColorImageRaw(cmdBuffer = %p, image = %p, color = [%i, %i, %i, %i], rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3], pPacket->rangeCount, (void*)(pPacket->pRanges));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdClearDepthStencil:
-    {
-        struct_xglCmdClearDepthStencil* pPacket = (struct_xglCmdClearDepthStencil*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdClearDepthStencil(cmdBuffer = %p, image = %p, depth = %f, stencil = %i, rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->depth, pPacket->stencil, pPacket->rangeCount, (void*)(pPacket->pRanges));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdResolveImage:
-    {
-        struct_xglCmdResolveImage* pPacket = (struct_xglCmdResolveImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdResolveImage(cmdBuffer = %p, srcImage = %p, destImage = %p, rectCount = %i, pRects = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destImage), pPacket->rectCount, (void*)(pPacket->pRects));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdSetEvent:
-    {
-        struct_xglCmdSetEvent* pPacket = (struct_xglCmdSetEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdSetEvent(cmdBuffer = %p, event = %p, pipeEvent = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->event), (void*)(pPacket->pipeEvent));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdResetEvent:
-    {
-        struct_xglCmdResetEvent* pPacket = (struct_xglCmdResetEvent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdResetEvent(cmdBuffer = %p, event = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->event));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdWaitEvents:
-    {
-        struct_xglCmdWaitEvents* pPacket = (struct_xglCmdWaitEvents*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdWaitEvents(cmdBuffer = %p, pWaitInfo = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pWaitInfo));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdPipelineBarrier:
-    {
-        struct_xglCmdPipelineBarrier* pPacket = (struct_xglCmdPipelineBarrier*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdPipelineBarrier(cmdBuffer = %p, pBarrier = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pBarrier));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBeginQuery:
-    {
-        struct_xglCmdBeginQuery* pPacket = (struct_xglCmdBeginQuery*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBeginQuery(cmdBuffer = %p, queryPool = %p, slot = %i, flags = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->slot, pPacket->flags);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdEndQuery:
-    {
-        struct_xglCmdEndQuery* pPacket = (struct_xglCmdEndQuery*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdEndQuery(cmdBuffer = %p, queryPool = %p, slot = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->slot);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdResetQueryPool:
-    {
-        struct_xglCmdResetQueryPool* pPacket = (struct_xglCmdResetQueryPool*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdResetQueryPool(cmdBuffer = %p, queryPool = %p, startQuery = %i, queryCount = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdWriteTimestamp:
-    {
-        struct_xglCmdWriteTimestamp* pPacket = (struct_xglCmdWriteTimestamp*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdWriteTimestamp(cmdBuffer = %p, timestampType = %s, destBuffer = %p, destOffset = %p)", (void*)(pPacket->cmdBuffer), string_XGL_TIMESTAMP_TYPE(pPacket->timestampType), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdInitAtomicCounters:
-    {
-        struct_xglCmdInitAtomicCounters* pPacket = (struct_xglCmdInitAtomicCounters*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdInitAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, *pData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (pPacket->pData == NULL) ? 0 : *(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
-    {
-        struct_xglCmdLoadAtomicCounters* pPacket = (struct_xglCmdLoadAtomicCounters*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdLoadAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, srcBuffer = %p, srcOffset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (void*)(pPacket->srcBuffer), (void*)(pPacket->srcOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
-    {
-        struct_xglCmdSaveAtomicCounters* pPacket = (struct_xglCmdSaveAtomicCounters*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdSaveAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, destBuffer = %p, destOffset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateFramebuffer:
-    {
-        struct_xglCreateFramebuffer* pPacket = (struct_xglCreateFramebuffer*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateFramebuffer(device = %p, pCreateInfo = %p, pFramebuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pFramebuffer);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCreateRenderPass:
-    {
-        struct_xglCreateRenderPass* pPacket = (struct_xglCreateRenderPass*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCreateRenderPass(device = %p, pCreateInfo = %p, pRenderPass = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pRenderPass);
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdBeginRenderPass:
-    {
-        struct_xglCmdBeginRenderPass* pPacket = (struct_xglCmdBeginRenderPass*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdBeginRenderPass(cmdBuffer = %p, renderPass = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->renderPass));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdEndRenderPass:
-    {
-        struct_xglCmdEndRenderPass* pPacket = (struct_xglCmdEndRenderPass*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdEndRenderPass(cmdBuffer = %p, renderPass = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->renderPass));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetValidationLevel:
-    {
-        struct_xglDbgSetValidationLevel* pPacket = (struct_xglDbgSetValidationLevel*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetValidationLevel(device = %p, validationLevel = %p)", (void*)(pPacket->device), (void*)(pPacket->validationLevel));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
-    {
-        struct_xglDbgRegisterMsgCallback* pPacket = (struct_xglDbgRegisterMsgCallback*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgRegisterMsgCallback(pfnMsgCallback = %p, pUserData = %p)", (void*)(pPacket->pfnMsgCallback), (void*)(pPacket->pUserData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
-    {
-        struct_xglDbgUnregisterMsgCallback* pPacket = (struct_xglDbgUnregisterMsgCallback*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgUnregisterMsgCallback(pfnMsgCallback = %p)", (void*)(pPacket->pfnMsgCallback));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetMessageFilter:
-    {
-        struct_xglDbgSetMessageFilter* pPacket = (struct_xglDbgSetMessageFilter*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetMessageFilter(device = %p, msgCode = %i, filter = %p)", (void*)(pPacket->device), pPacket->msgCode, (void*)(pPacket->filter));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetObjectTag:
-    {
-        struct_xglDbgSetObjectTag* pPacket = (struct_xglDbgSetObjectTag*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetObjectTag(object = %p, tagSize = %zu, pTag = %p)", (void*)(pPacket->object), pPacket->tagSize, (void*)(pPacket->pTag));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetGlobalOption:
-    {
-        struct_xglDbgSetGlobalOption* pPacket = (struct_xglDbgSetGlobalOption*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetGlobalOption(dbgOption = %p, dataSize = %zu, pData = %p)", (void*)(pPacket->dbgOption), pPacket->dataSize, (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglDbgSetDeviceOption:
-    {
-        struct_xglDbgSetDeviceOption* pPacket = (struct_xglDbgSetDeviceOption*)(pHeader->pBody);
-        snprintf(str, 1024, "xglDbgSetDeviceOption(device = %p, dbgOption = %p, dataSize = %zu, pData = %p)", (void*)(pPacket->device), (void*)(pPacket->dbgOption), pPacket->dataSize, (void*)(pPacket->pData));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
-    {
-        struct_xglCmdDbgMarkerBegin* pPacket = (struct_xglCmdDbgMarkerBegin*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDbgMarkerBegin(cmdBuffer = %p, pMarker = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pMarker));
-        return str;
-    }
-    case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
-    {
-        struct_xglCmdDbgMarkerEnd* pPacket = (struct_xglCmdDbgMarkerEnd*)(pHeader->pBody);
-        snprintf(str, 1024, "xglCmdDbgMarkerEnd(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWsiX11AssociateConnection:
-    {
-        struct_xglWsiX11AssociateConnection* pPacket = (struct_xglWsiX11AssociateConnection*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWsiX11AssociateConnection(gpu = %p, pConnectionInfo = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pConnectionInfo));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWsiX11GetMSC:
-    {
-        struct_xglWsiX11GetMSC* pPacket = (struct_xglWsiX11GetMSC*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWsiX11GetMSC(device = %p, window = %i, crtc = %u, *pMsc = %lu)", (void*)(pPacket->device), pPacket->window, pPacket->crtc, (pPacket->pMsc == NULL) ? 0 : *(pPacket->pMsc));
-        return str;
-    }
-    case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
-    {
-        struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWsiX11CreatePresentableImage(device = %p, pCreateInfo = %p, pImage = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)(pPacket->pImage), (void*)pPacket->pMem);
-        return str;
-    }
-    case GLV_TPI_XGL_xglWsiX11QueuePresent:
-    {
-        struct_xglWsiX11QueuePresent* pPacket = (struct_xglWsiX11QueuePresent*)(pHeader->pBody);
-        snprintf(str, 1024, "xglWsiX11QueuePresent(queue = %p, pPresentInfo = %p, fence = %p)", (void*)(pPacket->queue), (void*)(pPacket->pPresentInfo), (void*)(pPacket->fence));
-        return str;
-    }
-    default:
-        return NULL;
-    }
-};
-
-static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)
-{
-    if (pHeader == NULL)
-    {
-        return NULL;
-    }
-    switch (pHeader->packet_id)
-    {
-        case GLV_TPI_XGL_xglApiVersion:
-        {
-            return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;
-        }
-        case GLV_TPI_XGL_xglCreateInstance:
-        {
-            return interpret_body_as_xglCreateInstance(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDestroyInstance:
-        {
-            return interpret_body_as_xglDestroyInstance(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglEnumerateGpus:
-        {
-            return interpret_body_as_xglEnumerateGpus(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetGpuInfo:
-        {
-            return interpret_body_as_xglGetGpuInfo(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetProcAddr:
-        {
-            return interpret_body_as_xglGetProcAddr(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDevice:
-        {
-            return interpret_body_as_xglCreateDevice(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDestroyDevice:
-        {
-            return interpret_body_as_xglDestroyDevice(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetExtensionSupport:
-        {
-            return interpret_body_as_xglGetExtensionSupport(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglEnumerateLayers:
-        {
-            return interpret_body_as_xglEnumerateLayers(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetDeviceQueue:
-        {
-            return interpret_body_as_xglGetDeviceQueue(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglQueueSubmit:
-        {
-            return interpret_body_as_xglQueueSubmit(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
-        {
-            return interpret_body_as_xglQueueSetGlobalMemReferences(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglQueueWaitIdle:
-        {
-            return interpret_body_as_xglQueueWaitIdle(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDeviceWaitIdle:
-        {
-            return interpret_body_as_xglDeviceWaitIdle(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglAllocMemory:
-        {
-            return interpret_body_as_xglAllocMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglFreeMemory:
-        {
-            return interpret_body_as_xglFreeMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSetMemoryPriority:
-        {
-            return interpret_body_as_xglSetMemoryPriority(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglMapMemory:
-        {
-            return interpret_body_as_xglMapMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglUnmapMemory:
-        {
-            return interpret_body_as_xglUnmapMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglPinSystemMemory:
-        {
-            return interpret_body_as_xglPinSystemMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
-        {
-            return interpret_body_as_xglGetMultiGpuCompatibility(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglOpenSharedMemory:
-        {
-            return interpret_body_as_xglOpenSharedMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
-        {
-            return interpret_body_as_xglOpenSharedQueueSemaphore(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglOpenPeerMemory:
-        {
-            return interpret_body_as_xglOpenPeerMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglOpenPeerImage:
-        {
-            return interpret_body_as_xglOpenPeerImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDestroyObject:
-        {
-            return interpret_body_as_xglDestroyObject(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetObjectInfo:
-        {
-            return interpret_body_as_xglGetObjectInfo(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBindObjectMemory:
-        {
-            return interpret_body_as_xglBindObjectMemory(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBindObjectMemoryRange:
-        {
-            return interpret_body_as_xglBindObjectMemoryRange(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBindImageMemoryRange:
-        {
-            return interpret_body_as_xglBindImageMemoryRange(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateFence:
-        {
-            return interpret_body_as_xglCreateFence(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetFenceStatus:
-        {
-            return interpret_body_as_xglGetFenceStatus(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglWaitForFences:
-        {
-            return interpret_body_as_xglWaitForFences(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateQueueSemaphore:
-        {
-            return interpret_body_as_xglCreateQueueSemaphore(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSignalQueueSemaphore:
-        {
-            return interpret_body_as_xglSignalQueueSemaphore(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglWaitQueueSemaphore:
-        {
-            return interpret_body_as_xglWaitQueueSemaphore(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateEvent:
-        {
-            return interpret_body_as_xglCreateEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetEventStatus:
-        {
-            return interpret_body_as_xglGetEventStatus(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSetEvent:
-        {
-            return interpret_body_as_xglSetEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglResetEvent:
-        {
-            return interpret_body_as_xglResetEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateQueryPool:
-        {
-            return interpret_body_as_xglCreateQueryPool(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetQueryPoolResults:
-        {
-            return interpret_body_as_xglGetQueryPoolResults(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetFormatInfo:
-        {
-            return interpret_body_as_xglGetFormatInfo(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateBuffer:
-        {
-            return interpret_body_as_xglCreateBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateBufferView:
-        {
-            return interpret_body_as_xglCreateBufferView(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateImage:
-        {
-            return interpret_body_as_xglCreateImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSetFastClearColor:
-        {
-            return interpret_body_as_xglSetFastClearColor(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglSetFastClearDepth:
-        {
-            return interpret_body_as_xglSetFastClearDepth(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglGetImageSubresourceInfo:
-        {
-            return interpret_body_as_xglGetImageSubresourceInfo(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateImageView:
-        {
-            return interpret_body_as_xglCreateImageView(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateColorAttachmentView:
-        {
-            return interpret_body_as_xglCreateColorAttachmentView(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDepthStencilView:
-        {
-            return interpret_body_as_xglCreateDepthStencilView(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateShader:
-        {
-            return interpret_body_as_xglCreateShader(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateGraphicsPipeline:
-        {
-            return interpret_body_as_xglCreateGraphicsPipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateComputePipeline:
-        {
-            return interpret_body_as_xglCreateComputePipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglStorePipeline:
-        {
-            return interpret_body_as_xglStorePipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglLoadPipeline:
-        {
-            return interpret_body_as_xglLoadPipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreatePipelineDelta:
-        {
-            return interpret_body_as_xglCreatePipelineDelta(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateSampler:
-        {
-            return interpret_body_as_xglCreateSampler(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
-        {
-            return interpret_body_as_xglCreateDescriptorSetLayout(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
-        {
-            return interpret_body_as_xglBeginDescriptorRegionUpdate(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
-        {
-            return interpret_body_as_xglEndDescriptorRegionUpdate(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDescriptorRegion:
-        {
-            return interpret_body_as_xglCreateDescriptorRegion(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglClearDescriptorRegion:
-        {
-            return interpret_body_as_xglClearDescriptorRegion(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglAllocDescriptorSets:
-        {
-            return interpret_body_as_xglAllocDescriptorSets(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglClearDescriptorSets:
-        {
-            return interpret_body_as_xglClearDescriptorSets(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglUpdateDescriptors:
-        {
-            return interpret_body_as_xglUpdateDescriptors(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDynamicViewportState:
-        {
-            return interpret_body_as_xglCreateDynamicViewportState(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDynamicRasterState:
-        {
-            return interpret_body_as_xglCreateDynamicRasterState(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
-        {
-            return interpret_body_as_xglCreateDynamicColorBlendState(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
-        {
-            return interpret_body_as_xglCreateDynamicDepthStencilState(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateCommandBuffer:
-        {
-            return interpret_body_as_xglCreateCommandBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglBeginCommandBuffer:
-        {
-            return interpret_body_as_xglBeginCommandBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglEndCommandBuffer:
-        {
-            return interpret_body_as_xglEndCommandBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglResetCommandBuffer:
-        {
-            return interpret_body_as_xglResetCommandBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindPipeline:
-        {
-            return interpret_body_as_xglCmdBindPipeline(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindPipelineDelta:
-        {
-            return interpret_body_as_xglCmdBindPipelineDelta(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
-        {
-            return interpret_body_as_xglCmdBindDynamicStateObject(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindDescriptorSet:
-        {
-            return interpret_body_as_xglCmdBindDescriptorSet(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindVertexBuffer:
-        {
-            return interpret_body_as_xglCmdBindVertexBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBindIndexBuffer:
-        {
-            return interpret_body_as_xglCmdBindIndexBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDraw:
-        {
-            return interpret_body_as_xglCmdDraw(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDrawIndexed:
-        {
-            return interpret_body_as_xglCmdDrawIndexed(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDrawIndirect:
-        {
-            return interpret_body_as_xglCmdDrawIndirect(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
-        {
-            return interpret_body_as_xglCmdDrawIndexedIndirect(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDispatch:
-        {
-            return interpret_body_as_xglCmdDispatch(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdDispatchIndirect:
-        {
-            return interpret_body_as_xglCmdDispatchIndirect(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCopyBuffer:
-        {
-            return interpret_body_as_xglCmdCopyBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCopyImage:
-        {
-            return interpret_body_as_xglCmdCopyImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCopyBufferToImage:
-        {
-            return interpret_body_as_xglCmdCopyBufferToImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
-        {
-            return interpret_body_as_xglCmdCopyImageToBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdCloneImageData:
-        {
-            return interpret_body_as_xglCmdCloneImageData(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdUpdateBuffer:
-        {
-            return interpret_body_as_xglCmdUpdateBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdFillBuffer:
-        {
-            return interpret_body_as_xglCmdFillBuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdClearColorImage:
-        {
-            return interpret_body_as_xglCmdClearColorImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdClearColorImageRaw:
-        {
-            return interpret_body_as_xglCmdClearColorImageRaw(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdClearDepthStencil:
-        {
-            return interpret_body_as_xglCmdClearDepthStencil(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdResolveImage:
-        {
-            return interpret_body_as_xglCmdResolveImage(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdSetEvent:
-        {
-            return interpret_body_as_xglCmdSetEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdResetEvent:
-        {
-            return interpret_body_as_xglCmdResetEvent(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdWaitEvents:
-        {
-            return interpret_body_as_xglCmdWaitEvents(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdPipelineBarrier:
-        {
-            return interpret_body_as_xglCmdPipelineBarrier(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBeginQuery:
-        {
-            return interpret_body_as_xglCmdBeginQuery(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdEndQuery:
-        {
-            return interpret_body_as_xglCmdEndQuery(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdResetQueryPool:
-        {
-            return interpret_body_as_xglCmdResetQueryPool(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdWriteTimestamp:
-        {
-            return interpret_body_as_xglCmdWriteTimestamp(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdInitAtomicCounters:
-        {
-            return interpret_body_as_xglCmdInitAtomicCounters(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
-        {
-            return interpret_body_as_xglCmdLoadAtomicCounters(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
-        {
-            return interpret_body_as_xglCmdSaveAtomicCounters(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateFramebuffer:
-        {
-            return interpret_body_as_xglCreateFramebuffer(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCreateRenderPass:
-        {
-            return interpret_body_as_xglCreateRenderPass(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdBeginRenderPass:
-        {
-            return interpret_body_as_xglCmdBeginRenderPass(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglCmdEndRenderPass:
-        {
-            return interpret_body_as_xglCmdEndRenderPass(pHeader)->header;
-        }
-        case GLV_TPI_XGL_xglDbgSetValidationLevel:
-        {
-            return interpret_body_as_xglDbgSetValidationLevel(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
-        {
-            return interpret_body_as_xglDbgRegisterMsgCallback(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
-        {
-            return interpret_body_as_xglDbgUnregisterMsgCallback(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgSetMessageFilter:
-        {
-            return interpret_body_as_xglDbgSetMessageFilter(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgSetObjectTag:
-        {
-            return interpret_body_as_xglDbgSetObjectTag(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgSetGlobalOption:
-        {
-            return interpret_body_as_xglDbgSetGlobalOption(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglDbgSetDeviceOption:
-        {
-            return interpret_body_as_xglDbgSetDeviceOption(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
-        {
-            return interpret_body_as_xglCmdDbgMarkerBegin(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
-        {
-            return interpret_body_as_xglCmdDbgMarkerEnd(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglWsiX11AssociateConnection:
-        {
-            return interpret_body_as_xglWsiX11AssociateConnection(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglWsiX11GetMSC:
-        {
-            return interpret_body_as_xglWsiX11GetMSC(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
-        {
-            return interpret_body_as_xglWsiX11CreatePresentableImage(pHeader)->pHeader;
-        }
-        case GLV_TPI_XGL_xglWsiX11QueuePresent:
-        {
-            return interpret_body_as_xglWsiX11QueuePresent(pHeader)->pHeader;
-        }
-        default:
-            return NULL;
-    }
-    return NULL;
-}
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h
index 6284559..4de693d 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h
@@ -24,8 +24,8 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_packet_id.h"
 
 void AttachHooks();
 void DetachHooks();
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c
index a298093..c0e9cc7 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c
@@ -28,8 +28,8 @@
 #include "glv_common.h"
 #include "glvtrace_xgl_xgl.h"
 #include "glvtrace_xgl_xgldbg.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_packet_id.h"
 #ifdef WIN32
 #include "mhook/mhook-lib/mhook.h"
 #endif
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c
index 8328257..4a8da11 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c
@@ -27,8 +27,8 @@
 #include "glv_platform.h"
 #include "glv_common.h"
 #include "glvtrace_xgl_xglwsix11ext.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_vkwsix11ext_structs.h"
+#include "glv_vk_packet_id.h"
 #ifdef WIN32
 #include "mhook/mhook-lib/mhook.h"
 #endif
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h
index b3a9606..a81bb7b 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h
@@ -3,64 +3,6 @@
 #include <xgl.h>
 
 
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
-    switch ((XGL_STENCIL_OP)input_value)
-    {
-        case XGL_STENCIL_OP_DEC_CLAMP:
-            return "XGL_STENCIL_OP_DEC_CLAMP";
-        case XGL_STENCIL_OP_DEC_WRAP:
-            return "XGL_STENCIL_OP_DEC_WRAP";
-        case XGL_STENCIL_OP_INC_CLAMP:
-            return "XGL_STENCIL_OP_INC_CLAMP";
-        case XGL_STENCIL_OP_INC_WRAP:
-            return "XGL_STENCIL_OP_INC_WRAP";
-        case XGL_STENCIL_OP_INVERT:
-            return "XGL_STENCIL_OP_INVERT";
-        case XGL_STENCIL_OP_KEEP:
-            return "XGL_STENCIL_OP_KEEP";
-        case XGL_STENCIL_OP_REPLACE:
-            return "XGL_STENCIL_OP_REPLACE";
-        case XGL_STENCIL_OP_ZERO:
-            return "XGL_STENCIL_OP_ZERO";
-        default:
-            return "Unhandled XGL_STENCIL_OP";
-    }
-}
-
-
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
-    {
-        case XGL_SYSTEM_ALLOC_API_OBJECT:
-            return "XGL_SYSTEM_ALLOC_API_OBJECT";
-        case XGL_SYSTEM_ALLOC_DEBUG:
-            return "XGL_SYSTEM_ALLOC_DEBUG";
-        case XGL_SYSTEM_ALLOC_INTERNAL:
-            return "XGL_SYSTEM_ALLOC_INTERNAL";
-        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
-            return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
-        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
-            return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
-        default:
-            return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
-    {
-        case XGL_MEMORY_REF_READ_ONLY_BIT:
-            return "XGL_MEMORY_REF_READ_ONLY_BIT";
-        default:
-            return "Unhandled XGL_MEMORY_REF_FLAGS";
-    }
-}
-
-
 static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
 {
     switch ((XGL_PIPELINE_BIND_POINT)input_value)
@@ -75,56 +17,52 @@
 }
 
 
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
     {
-        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
-            return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
-        case XGL_MEMORY_OUTPUT_COPY_BIT:
-            return "XGL_MEMORY_OUTPUT_COPY_BIT";
-        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
-            return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
-        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-            return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
-        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
-            return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+        case XGL_SHADER_STAGE_COMPUTE:
+            return "XGL_SHADER_STAGE_COMPUTE";
+        case XGL_SHADER_STAGE_FRAGMENT:
+            return "XGL_SHADER_STAGE_FRAGMENT";
+        case XGL_SHADER_STAGE_GEOMETRY:
+            return "XGL_SHADER_STAGE_GEOMETRY";
+        case XGL_SHADER_STAGE_TESS_CONTROL:
+            return "XGL_SHADER_STAGE_TESS_CONTROL";
+        case XGL_SHADER_STAGE_TESS_EVALUATION:
+            return "XGL_SHADER_STAGE_TESS_EVALUATION";
+        case XGL_SHADER_STAGE_VERTEX:
+            return "XGL_SHADER_STAGE_VERTEX";
         default:
-            return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+            return "Unhandled XGL_PIPELINE_SHADER_STAGE";
     }
 }
 
 
-static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
     {
-        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
-            return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
-        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
-            return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
-        case XGL_ATTACHMENT_STORE_OP_STORE:
-            return "XGL_ATTACHMENT_STORE_OP_STORE";
+        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
         default:
-            return "Unhandled XGL_ATTACHMENT_STORE_OP";
+            return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
 {
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
+    switch ((XGL_MEMORY_TYPE)input_value)
     {
-        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
-        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
-        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
-            return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
-        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
-            return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
+        case XGL_MEMORY_TYPE_BUFFER:
+            return "XGL_MEMORY_TYPE_BUFFER";
+        case XGL_MEMORY_TYPE_IMAGE:
+            return "XGL_MEMORY_TYPE_IMAGE";
+        case XGL_MEMORY_TYPE_OTHER:
+            return "XGL_MEMORY_TYPE_OTHER";
         default:
-            return "Unhandled XGL_OBJECT_INFO_TYPE";
+            return "Unhandled XGL_MEMORY_TYPE";
     }
 }
 
@@ -151,950 +89,16 @@
 }
 
 
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+    switch ((XGL_DEPTH_MODE)input_value)
     {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
+        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+            return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+        case XGL_DEPTH_MODE_ZERO_TO_ONE:
+            return "XGL_DEPTH_MODE_ZERO_TO_ONE";
         default:
-            return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
-{
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
-    {
-        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
-            return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
-        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
-            return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
-        default:
-            return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
-{
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
-    {
-        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
-            return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
-        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
-            return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
-        case XGL_IMAGE_USAGE_GENERAL:
-            return "XGL_IMAGE_USAGE_GENERAL";
-        case XGL_IMAGE_USAGE_IMAGE_BIT:
-            return "XGL_IMAGE_USAGE_IMAGE_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
-            return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
-        case XGL_IMAGE_USAGE_TEXTURE_BIT:
-            return "XGL_IMAGE_USAGE_TEXTURE_BIT";
-        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
-            return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
-        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
-            return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
-        default:
-            return "Unhandled XGL_IMAGE_USAGE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
-{
-    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
-    {
-        case XGL_IMAGE_FORMAT_CLASS_128_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
-            return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
-        case XGL_IMAGE_FORMAT_CLASS_16_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_24_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_32_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_48_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_64_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
-            return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
-        case XGL_IMAGE_FORMAT_CLASS_8_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_96_BITS:
-            return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
-        case XGL_IMAGE_FORMAT_CLASS_D16:
-            return "XGL_IMAGE_FORMAT_CLASS_D16";
-        case XGL_IMAGE_FORMAT_CLASS_D16S8:
-            return "XGL_IMAGE_FORMAT_CLASS_D16S8";
-        case XGL_IMAGE_FORMAT_CLASS_D24:
-            return "XGL_IMAGE_FORMAT_CLASS_D24";
-        case XGL_IMAGE_FORMAT_CLASS_D24S8:
-            return "XGL_IMAGE_FORMAT_CLASS_D24S8";
-        case XGL_IMAGE_FORMAT_CLASS_D32:
-            return "XGL_IMAGE_FORMAT_CLASS_D32";
-        case XGL_IMAGE_FORMAT_CLASS_D32S8:
-            return "XGL_IMAGE_FORMAT_CLASS_D32S8";
-        case XGL_IMAGE_FORMAT_CLASS_LINEAR:
-            return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
-        case XGL_IMAGE_FORMAT_CLASS_S8:
-            return "XGL_IMAGE_FORMAT_CLASS_S8";
-        default:
-            return "Unhandled XGL_IMAGE_FORMAT_CLASS";
-    }
-}
-
-
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
-    switch ((XGL_QUERY_TYPE)input_value)
-    {
-        case XGL_QUERY_OCCLUSION:
-            return "XGL_QUERY_OCCLUSION";
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return "XGL_QUERY_PIPELINE_STATISTICS";
-        default:
-            return "Unhandled XGL_QUERY_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
-    switch ((XGL_STRUCTURE_TYPE)input_value)
-    {
-        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
-            return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
-        case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
-            return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
-        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
-            return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
-        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
-            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
-            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
-        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
-            return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
-        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
-            return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
-            return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
-            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
-            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
-            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
-        case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
-            return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
-        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
-            return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
-        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
-            return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
-        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
-            return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
-        case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
-            return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
-            return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-            return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-            return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-            return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
-        default:
-            return "Unhandled XGL_STRUCTURE_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
-    {
-        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
-            return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
-        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
-            return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
-        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
-            return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
-        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
-            return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
-        case XGL_IMAGE_CREATE_SPARSE_BIT:
-            return "XGL_IMAGE_CREATE_SPARSE_BIT";
-        default:
-            return "Unhandled XGL_IMAGE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
-    {
-        case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
-            return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
-        case XGL_MEMORY_INPUT_COPY_BIT:
-            return "XGL_MEMORY_INPUT_COPY_BIT";
-        case XGL_MEMORY_INPUT_CPU_READ_BIT:
-            return "XGL_MEMORY_INPUT_CPU_READ_BIT";
-        case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-            return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
-        case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
-            return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
-        case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
-            return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
-        case XGL_MEMORY_INPUT_SHADER_READ_BIT:
-            return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
-        case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
-            return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
-        case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
-            return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
-        default:
-            return "Unhandled XGL_MEMORY_INPUT_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
-    switch ((XGL_IMAGE_ASPECT)input_value)
-    {
-        case XGL_IMAGE_ASPECT_COLOR:
-            return "XGL_IMAGE_ASPECT_COLOR";
-        case XGL_IMAGE_ASPECT_DEPTH:
-            return "XGL_IMAGE_ASPECT_DEPTH";
-        case XGL_IMAGE_ASPECT_STENCIL:
-            return "XGL_IMAGE_ASPECT_STENCIL";
-        default:
-            return "Unhandled XGL_IMAGE_ASPECT";
-    }
-}
-
-
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
-    {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-            return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
-            return "XGL_DEVICE_CREATE_VALIDATION_BIT";
-        default:
-            return "Unhandled XGL_DEVICE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
-    switch ((XGL_COMPARE_FUNC)input_value)
-    {
-        case XGL_COMPARE_ALWAYS:
-            return "XGL_COMPARE_ALWAYS";
-        case XGL_COMPARE_EQUAL:
-            return "XGL_COMPARE_EQUAL";
-        case XGL_COMPARE_GREATER:
-            return "XGL_COMPARE_GREATER";
-        case XGL_COMPARE_GREATER_EQUAL:
-            return "XGL_COMPARE_GREATER_EQUAL";
-        case XGL_COMPARE_LESS:
-            return "XGL_COMPARE_LESS";
-        case XGL_COMPARE_LESS_EQUAL:
-            return "XGL_COMPARE_LESS_EQUAL";
-        case XGL_COMPARE_NEVER:
-            return "XGL_COMPARE_NEVER";
-        case XGL_COMPARE_NOT_EQUAL:
-            return "XGL_COMPARE_NOT_EQUAL";
-        default:
-            return "Unhandled XGL_COMPARE_FUNC";
-    }
-}
-
-
-static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
-{
-    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
-    {
-        case XGL_SHADER_STAGE_FLAGS_ALL:
-            return "XGL_SHADER_STAGE_FLAGS_ALL";
-        case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
-        case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
-        case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
-        case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
-        case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
-        case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
-            return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
-        default:
-            return "Unhandled XGL_SHADER_STAGE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
-    switch ((XGL_FILL_MODE)input_value)
-    {
-        case XGL_FILL_POINTS:
-            return "XGL_FILL_POINTS";
-        case XGL_FILL_SOLID:
-            return "XGL_FILL_SOLID";
-        case XGL_FILL_WIREFRAME:
-            return "XGL_FILL_WIREFRAME";
-        default:
-            return "Unhandled XGL_FILL_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
-    switch ((XGL_COORDINATE_ORIGIN)input_value)
-    {
-        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
-            return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
-        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
-            return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
-        default:
-            return "Unhandled XGL_COORDINATE_ORIGIN";
-    }
-}
-
-
-static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
-    switch ((XGL_WAIT_EVENT)input_value)
-    {
-        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
-            return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
-        case XGL_WAIT_EVENT_TOP_OF_PIPE:
-            return "XGL_WAIT_EVENT_TOP_OF_PIPE";
-        default:
-            return "Unhandled XGL_WAIT_EVENT";
-    }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
-    {
-        case XGL_DESCRIPTOR_TYPE_IMAGE:
-            return "XGL_DESCRIPTOR_TYPE_IMAGE";
-        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
-        case XGL_DESCRIPTOR_TYPE_SAMPLER:
-            return "XGL_DESCRIPTOR_TYPE_SAMPLER";
-        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
-            return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
-        case XGL_DESCRIPTOR_TYPE_TEXTURE:
-            return "XGL_DESCRIPTOR_TYPE_TEXTURE";
-        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
-        default:
-            return "Unhandled XGL_DESCRIPTOR_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
-    {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
-        default:
-            return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
-    switch ((XGL_MEMORY_PRIORITY)input_value)
-    {
-        case XGL_MEMORY_PRIORITY_HIGH:
-            return "XGL_MEMORY_PRIORITY_HIGH";
-        case XGL_MEMORY_PRIORITY_LOW:
-            return "XGL_MEMORY_PRIORITY_LOW";
-        case XGL_MEMORY_PRIORITY_NORMAL:
-            return "XGL_MEMORY_PRIORITY_NORMAL";
-        case XGL_MEMORY_PRIORITY_UNUSED:
-            return "XGL_MEMORY_PRIORITY_UNUSED";
-        case XGL_MEMORY_PRIORITY_VERY_HIGH:
-            return "XGL_MEMORY_PRIORITY_VERY_HIGH";
-        case XGL_MEMORY_PRIORITY_VERY_LOW:
-            return "XGL_MEMORY_PRIORITY_VERY_LOW";
-        default:
-            return "Unhandled XGL_MEMORY_PRIORITY";
-    }
-}
-
-
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
-    {
-        case XGL_TIMESTAMP_BOTTOM:
-            return "XGL_TIMESTAMP_BOTTOM";
-        case XGL_TIMESTAMP_TOP:
-            return "XGL_TIMESTAMP_TOP";
-        default:
-            return "Unhandled XGL_TIMESTAMP_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
-    {
-        case XGL_GPU_TYPE_DISCRETE:
-            return "XGL_GPU_TYPE_DISCRETE";
-        case XGL_GPU_TYPE_INTEGRATED:
-            return "XGL_GPU_TYPE_INTEGRATED";
-        case XGL_GPU_TYPE_OTHER:
-            return "XGL_GPU_TYPE_OTHER";
-        case XGL_GPU_TYPE_VIRTUAL:
-            return "XGL_GPU_TYPE_VIRTUAL";
-        default:
-            return "Unhandled XGL_PHYSICAL_GPU_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
-{
-    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
-    {
-        case XGL_TOPOLOGY_LINE_LIST:
-            return "XGL_TOPOLOGY_LINE_LIST";
-        case XGL_TOPOLOGY_LINE_LIST_ADJ:
-            return "XGL_TOPOLOGY_LINE_LIST_ADJ";
-        case XGL_TOPOLOGY_LINE_STRIP:
-            return "XGL_TOPOLOGY_LINE_STRIP";
-        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
-            return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
-        case XGL_TOPOLOGY_PATCH:
-            return "XGL_TOPOLOGY_PATCH";
-        case XGL_TOPOLOGY_POINT_LIST:
-            return "XGL_TOPOLOGY_POINT_LIST";
-        case XGL_TOPOLOGY_QUAD_LIST:
-            return "XGL_TOPOLOGY_QUAD_LIST";
-        case XGL_TOPOLOGY_QUAD_STRIP:
-            return "XGL_TOPOLOGY_QUAD_STRIP";
-        case XGL_TOPOLOGY_RECT_LIST:
-            return "XGL_TOPOLOGY_RECT_LIST";
-        case XGL_TOPOLOGY_TRIANGLE_LIST:
-            return "XGL_TOPOLOGY_TRIANGLE_LIST";
-        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
-            return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
-        case XGL_TOPOLOGY_TRIANGLE_STRIP:
-            return "XGL_TOPOLOGY_TRIANGLE_STRIP";
-        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
-            return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
-        default:
-            return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
-    {
-        case XGL_IMAGE_VIEW_1D:
-            return "XGL_IMAGE_VIEW_1D";
-        case XGL_IMAGE_VIEW_2D:
-            return "XGL_IMAGE_VIEW_2D";
-        case XGL_IMAGE_VIEW_3D:
-            return "XGL_IMAGE_VIEW_3D";
-        case XGL_IMAGE_VIEW_CUBE:
-            return "XGL_IMAGE_VIEW_CUBE";
-        default:
-            return "Unhandled XGL_IMAGE_VIEW_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
-    {
-        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
-            return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
-        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
-            return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
-        default:
-            return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
-    }
-}
-
-
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
-        default:
-            return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
-{
-    switch ((XGL_RESULT)input_value)
-    {
-        case XGL_ERROR_BAD_PIPELINE_DATA:
-            return "XGL_ERROR_BAD_PIPELINE_DATA";
-        case XGL_ERROR_BAD_SHADER_CODE:
-            return "XGL_ERROR_BAD_SHADER_CODE";
-        case XGL_ERROR_BUILDING_COMMAND_BUFFER:
-            return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
-        case XGL_ERROR_DEVICE_ALREADY_CREATED:
-            return "XGL_ERROR_DEVICE_ALREADY_CREATED";
-        case XGL_ERROR_DEVICE_LOST:
-            return "XGL_ERROR_DEVICE_LOST";
-        case XGL_ERROR_INCOMPATIBLE_DEVICE:
-            return "XGL_ERROR_INCOMPATIBLE_DEVICE";
-        case XGL_ERROR_INCOMPATIBLE_DRIVER:
-            return "XGL_ERROR_INCOMPATIBLE_DRIVER";
-        case XGL_ERROR_INCOMPATIBLE_QUEUE:
-            return "XGL_ERROR_INCOMPATIBLE_QUEUE";
-        case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
-            return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
-        case XGL_ERROR_INITIALIZATION_FAILED:
-            return "XGL_ERROR_INITIALIZATION_FAILED";
-        case XGL_ERROR_INVALID_ALIGNMENT:
-            return "XGL_ERROR_INVALID_ALIGNMENT";
-        case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
-            return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
-        case XGL_ERROR_INVALID_EXTENSION:
-            return "XGL_ERROR_INVALID_EXTENSION";
-        case XGL_ERROR_INVALID_FLAGS:
-            return "XGL_ERROR_INVALID_FLAGS";
-        case XGL_ERROR_INVALID_FORMAT:
-            return "XGL_ERROR_INVALID_FORMAT";
-        case XGL_ERROR_INVALID_HANDLE:
-            return "XGL_ERROR_INVALID_HANDLE";
-        case XGL_ERROR_INVALID_IMAGE:
-            return "XGL_ERROR_INVALID_IMAGE";
-        case XGL_ERROR_INVALID_MEMORY_SIZE:
-            return "XGL_ERROR_INVALID_MEMORY_SIZE";
-        case XGL_ERROR_INVALID_OBJECT_TYPE:
-            return "XGL_ERROR_INVALID_OBJECT_TYPE";
-        case XGL_ERROR_INVALID_ORDINAL:
-            return "XGL_ERROR_INVALID_ORDINAL";
-        case XGL_ERROR_INVALID_POINTER:
-            return "XGL_ERROR_INVALID_POINTER";
-        case XGL_ERROR_INVALID_QUEUE_TYPE:
-            return "XGL_ERROR_INVALID_QUEUE_TYPE";
-        case XGL_ERROR_INVALID_VALUE:
-            return "XGL_ERROR_INVALID_VALUE";
-        case XGL_ERROR_MEMORY_MAP_FAILED:
-            return "XGL_ERROR_MEMORY_MAP_FAILED";
-        case XGL_ERROR_MEMORY_NOT_BOUND:
-            return "XGL_ERROR_MEMORY_NOT_BOUND";
-        case XGL_ERROR_MEMORY_UNMAP_FAILED:
-            return "XGL_ERROR_MEMORY_UNMAP_FAILED";
-        case XGL_ERROR_NOT_MAPPABLE:
-            return "XGL_ERROR_NOT_MAPPABLE";
-        case XGL_ERROR_NOT_SHAREABLE:
-            return "XGL_ERROR_NOT_SHAREABLE";
-        case XGL_ERROR_OUT_OF_GPU_MEMORY:
-            return "XGL_ERROR_OUT_OF_GPU_MEMORY";
-        case XGL_ERROR_OUT_OF_MEMORY:
-            return "XGL_ERROR_OUT_OF_MEMORY";
-        case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
-            return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
-        case XGL_ERROR_UNAVAILABLE:
-            return "XGL_ERROR_UNAVAILABLE";
-        case XGL_ERROR_UNKNOWN:
-            return "XGL_ERROR_UNKNOWN";
-        case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
-            return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
-        case XGL_EVENT_RESET:
-            return "XGL_EVENT_RESET";
-        case XGL_EVENT_SET:
-            return "XGL_EVENT_SET";
-        case XGL_NOT_READY:
-            return "XGL_NOT_READY";
-        case XGL_SUCCESS:
-            return "XGL_SUCCESS";
-        case XGL_TIMEOUT:
-            return "XGL_TIMEOUT";
-        case XGL_UNSUPPORTED:
-            return "XGL_UNSUPPORTED";
-        default:
-            return "Unhandled XGL_RESULT";
-    }
-}
-
-
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
-    {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-            return "XGL_BORDER_COLOR_OPAQUE_BLACK";
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-            return "XGL_BORDER_COLOR_OPAQUE_WHITE";
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
-            return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
-        default:
-            return "Unhandled XGL_BORDER_COLOR_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
-        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
-            return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
-        default:
-            return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
-    {
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
-            return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
-            return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
-        default:
-            return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
-    switch ((XGL_INDEX_TYPE)input_value)
-    {
-        case XGL_INDEX_16:
-            return "XGL_INDEX_16";
-        case XGL_INDEX_32:
-            return "XGL_INDEX_32";
-        case XGL_INDEX_8:
-            return "XGL_INDEX_8";
-        default:
-            return "Unhandled XGL_INDEX_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
-    switch ((XGL_CULL_MODE)input_value)
-    {
-        case XGL_CULL_BACK:
-            return "XGL_CULL_BACK";
-        case XGL_CULL_FRONT:
-            return "XGL_CULL_FRONT";
-        case XGL_CULL_FRONT_AND_BACK:
-            return "XGL_CULL_FRONT_AND_BACK";
-        case XGL_CULL_NONE:
-            return "XGL_CULL_NONE";
-        default:
-            return "Unhandled XGL_CULL_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
-    switch ((XGL_SET_EVENT)input_value)
-    {
-        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
-            return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
-        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
-            return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
-        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
-            return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
-        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
-            return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
-        case XGL_SET_EVENT_TOP_OF_PIPE:
-            return "XGL_SET_EVENT_TOP_OF_PIPE";
-        case XGL_SET_EVENT_TRANSFER_COMPLETE:
-            return "XGL_SET_EVENT_TRANSFER_COMPLETE";
-        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
-            return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
-        default:
-            return "Unhandled XGL_SET_EVENT";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
-    {
-        case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
-            return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
-        case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
-            return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
-        case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
-            return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
-        case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
-            return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
-        case XGL_MEMORY_PROPERTY_GPU_ONLY:
-            return "XGL_MEMORY_PROPERTY_GPU_ONLY";
-        case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
-            return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
-        case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
-            return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
-        default:
-            return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
-{
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
-    {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-            return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-            return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
-            return "XGL_ATTACHMENT_LOAD_OP_LOAD";
-        default:
-            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
-    }
-}
-
-
-static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
-    {
-        case XGL_PROVOKING_VERTEX_FIRST:
-            return "XGL_PROVOKING_VERTEX_FIRST";
-        case XGL_PROVOKING_VERTEX_LAST:
-            return "XGL_PROVOKING_VERTEX_LAST";
-        default:
-            return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
-    }
-}
-
-
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
-    switch ((XGL_VALIDATION_LEVEL)input_value)
-    {
-        case XGL_VALIDATION_LEVEL_0:
-            return "XGL_VALIDATION_LEVEL_0";
-        case XGL_VALIDATION_LEVEL_1:
-            return "XGL_VALIDATION_LEVEL_1";
-        case XGL_VALIDATION_LEVEL_2:
-            return "XGL_VALIDATION_LEVEL_2";
-        case XGL_VALIDATION_LEVEL_3:
-            return "XGL_VALIDATION_LEVEL_3";
-        case XGL_VALIDATION_LEVEL_4:
-            return "XGL_VALIDATION_LEVEL_4";
-        default:
-            return "Unhandled XGL_VALIDATION_LEVEL";
-    }
-}
-
-
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
-    switch ((XGL_FACE_ORIENTATION)input_value)
-    {
-        case XGL_FRONT_FACE_CCW:
-            return "XGL_FRONT_FACE_CCW";
-        case XGL_FRONT_FACE_CW:
-            return "XGL_FRONT_FACE_CW";
-        default:
-            return "Unhandled XGL_FACE_ORIENTATION";
-    }
-}
-
-
-static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
-{
-    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
-    {
-        case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
-            return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
-        case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
-            return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
-        case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
-            return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
-        default:
-            return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
-    }
-}
-
-
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
-    switch ((XGL_QUEUE_FLAGS)input_value)
-    {
-        case XGL_QUEUE_COMPUTE_BIT:
-            return "XGL_QUEUE_COMPUTE_BIT";
-        case XGL_QUEUE_DMA_BIT:
-            return "XGL_QUEUE_DMA_BIT";
-        case XGL_QUEUE_EXTENDED_BIT:
-            return "XGL_QUEUE_EXTENDED_BIT";
-        case XGL_QUEUE_GRAPHICS_BIT:
-            return "XGL_QUEUE_GRAPHICS_BIT";
-        default:
-            return "Unhandled XGL_QUEUE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
-    {
-        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
-            return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
-        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
-            return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
-        default:
-            return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
-    }
-}
-
-
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
-    {
-        case XGL_TEX_MIPMAP_BASE:
-            return "XGL_TEX_MIPMAP_BASE";
-        case XGL_TEX_MIPMAP_LINEAR:
-            return "XGL_TEX_MIPMAP_LINEAR";
-        case XGL_TEX_MIPMAP_NEAREST:
-            return "XGL_TEX_MIPMAP_NEAREST";
-        default:
-            return "Unhandled XGL_TEX_MIPMAP_MODE";
-    }
-}
-
-
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
-    {
-        case XGL_QUERY_IMPRECISE_DATA_BIT:
-            return "XGL_QUERY_IMPRECISE_DATA_BIT";
-        default:
-            return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+            return "Unhandled XGL_DEPTH_MODE";
     }
 }
 
@@ -1443,48 +447,492 @@
 }
 
 
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
 {
-    switch ((XGL_DEPTH_MODE)input_value)
+    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
     {
-        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
-            return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
-        case XGL_DEPTH_MODE_ZERO_TO_ONE:
-            return "XGL_DEPTH_MODE_ZERO_TO_ONE";
+        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+            return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
+        case XGL_BUFFER_CREATE_SPARSE_BIT:
+            return "XGL_BUFFER_CREATE_SPARSE_BIT";
         default:
-            return "Unhandled XGL_DEPTH_MODE";
+            return "Unhandled XGL_BUFFER_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
 {
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
     {
-        case XGL_BUFFER_VIEW_RAW:
-            return "XGL_BUFFER_VIEW_RAW";
-        case XGL_BUFFER_VIEW_STRUCTURED:
-            return "XGL_BUFFER_VIEW_STRUCTURED";
-        case XGL_BUFFER_VIEW_TYPED:
-            return "XGL_BUFFER_VIEW_TYPED";
+        case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+            return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
+        case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+            return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
+        case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+            return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
+        case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+            return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
+        case XGL_MEMORY_PROPERTY_GPU_ONLY:
+            return "XGL_MEMORY_PROPERTY_GPU_ONLY";
+        case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+            return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
+        case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+            return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
         default:
-            return "Unhandled XGL_BUFFER_VIEW_TYPE";
+            return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
     {
-        case XGL_IMAGE_1D:
-            return "XGL_IMAGE_1D";
-        case XGL_IMAGE_2D:
-            return "XGL_IMAGE_2D";
-        case XGL_IMAGE_3D:
-            return "XGL_IMAGE_3D";
+        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+            return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+            return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
         default:
-            return "Unhandled XGL_IMAGE_TYPE";
+            return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+    }
+}
+
+
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+    switch ((XGL_COORDINATE_ORIGIN)input_value)
+    {
+        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+            return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+            return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+        default:
+            return "Unhandled XGL_COORDINATE_ORIGIN";
+    }
+}
+
+
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+    switch ((XGL_CULL_MODE)input_value)
+    {
+        case XGL_CULL_BACK:
+            return "XGL_CULL_BACK";
+        case XGL_CULL_FRONT:
+            return "XGL_CULL_FRONT";
+        case XGL_CULL_FRONT_AND_BACK:
+            return "XGL_CULL_FRONT_AND_BACK";
+        case XGL_CULL_NONE:
+            return "XGL_CULL_NONE";
+        default:
+            return "Unhandled XGL_CULL_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+{
+    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+    {
+        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+            return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+            return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+        case XGL_IMAGE_USAGE_GENERAL:
+            return "XGL_IMAGE_USAGE_GENERAL";
+        case XGL_IMAGE_USAGE_IMAGE_BIT:
+            return "XGL_IMAGE_USAGE_IMAGE_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+            return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+        case XGL_IMAGE_USAGE_TEXTURE_BIT:
+            return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+            return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+            return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
+        default:
+            return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    {
+        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+            return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+        case XGL_MEMORY_OUTPUT_COPY_BIT:
+            return "XGL_MEMORY_OUTPUT_COPY_BIT";
+        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+            return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+            return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+            return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+        default:
+            return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+    switch ((XGL_SET_EVENT)input_value)
+    {
+        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+            return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
+        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+            return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+            return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
+        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+            return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+        case XGL_SET_EVENT_TOP_OF_PIPE:
+            return "XGL_SET_EVENT_TOP_OF_PIPE";
+        case XGL_SET_EVENT_TRANSFER_COMPLETE:
+            return "XGL_SET_EVENT_TRANSFER_COMPLETE";
+        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+            return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
+        default:
+            return "Unhandled XGL_SET_EVENT";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+    {
+        case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+            return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
+        case XGL_MEMORY_INPUT_COPY_BIT:
+            return "XGL_MEMORY_INPUT_COPY_BIT";
+        case XGL_MEMORY_INPUT_CPU_READ_BIT:
+            return "XGL_MEMORY_INPUT_CPU_READ_BIT";
+        case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+            return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+        case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+            return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
+        case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+            return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
+        case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+            return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
+        case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+            return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
+        case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+            return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
+        default:
+            return "Unhandled XGL_MEMORY_INPUT_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+{
+    switch ((XGL_TEX_MIPMAP_MODE)input_value)
+    {
+        case XGL_TEX_MIPMAP_BASE:
+            return "XGL_TEX_MIPMAP_BASE";
+        case XGL_TEX_MIPMAP_LINEAR:
+            return "XGL_TEX_MIPMAP_LINEAR";
+        case XGL_TEX_MIPMAP_NEAREST:
+            return "XGL_TEX_MIPMAP_NEAREST";
+        default:
+            return "Unhandled XGL_TEX_MIPMAP_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    {
+        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+            return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+            return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+    switch ((XGL_STRUCTURE_TYPE)input_value)
+    {
+        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+            return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
+        case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+            return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+            return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
+        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+            return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
+        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+            return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
+        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+            return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+            return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
+        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+            return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
+        case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+            return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
+        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+            return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
+        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+            return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
+        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+            return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
+        case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+            return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
+        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+            return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
+        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+            return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
+        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+            return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
+        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+            return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
+        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
+        default:
+            return "Unhandled XGL_STRUCTURE_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_REF_FLAGS)input_value)
+    {
+        case XGL_MEMORY_REF_READ_ONLY_BIT:
+            return "XGL_MEMORY_REF_READ_ONLY_BIT";
+        default:
+            return "Unhandled XGL_MEMORY_REF_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    {
+        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+            return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+            return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+    }
+}
+
+
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    {
+        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+        default:
+            return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+    switch ((XGL_WAIT_EVENT)input_value)
+    {
+        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+            return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
+        case XGL_WAIT_EVENT_TOP_OF_PIPE:
+            return "XGL_WAIT_EVENT_TOP_OF_PIPE";
+        default:
+            return "Unhandled XGL_WAIT_EVENT";
+    }
+}
+
+
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+{
+    switch ((XGL_QUEUE_FLAGS)input_value)
+    {
+        case XGL_QUEUE_COMPUTE_BIT:
+            return "XGL_QUEUE_COMPUTE_BIT";
+        case XGL_QUEUE_DMA_BIT:
+            return "XGL_QUEUE_DMA_BIT";
+        case XGL_QUEUE_EXTENDED_BIT:
+            return "XGL_QUEUE_EXTENDED_BIT";
+        case XGL_QUEUE_GRAPHICS_BIT:
+            return "XGL_QUEUE_GRAPHICS_BIT";
+        default:
+            return "Unhandled XGL_QUEUE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+{
+    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+    {
+        case XGL_SYSTEM_ALLOC_API_OBJECT:
+            return "XGL_SYSTEM_ALLOC_API_OBJECT";
+        case XGL_SYSTEM_ALLOC_DEBUG:
+            return "XGL_SYSTEM_ALLOC_DEBUG";
+        case XGL_SYSTEM_ALLOC_INTERNAL:
+            return "XGL_SYSTEM_ALLOC_INTERNAL";
+        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+            return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+            return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
+        default:
+            return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+{
+    switch ((XGL_VALIDATION_LEVEL)input_value)
+    {
+        case XGL_VALIDATION_LEVEL_0:
+            return "XGL_VALIDATION_LEVEL_0";
+        case XGL_VALIDATION_LEVEL_1:
+            return "XGL_VALIDATION_LEVEL_1";
+        case XGL_VALIDATION_LEVEL_2:
+            return "XGL_VALIDATION_LEVEL_2";
+        case XGL_VALIDATION_LEVEL_3:
+            return "XGL_VALIDATION_LEVEL_3";
+        case XGL_VALIDATION_LEVEL_4:
+            return "XGL_VALIDATION_LEVEL_4";
+        default:
+            return "Unhandled XGL_VALIDATION_LEVEL";
+    }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    {
+        case XGL_GPU_TYPE_DISCRETE:
+            return "XGL_GPU_TYPE_DISCRETE";
+        case XGL_GPU_TYPE_INTEGRATED:
+            return "XGL_GPU_TYPE_INTEGRATED";
+        case XGL_GPU_TYPE_OTHER:
+            return "XGL_GPU_TYPE_OTHER";
+        case XGL_GPU_TYPE_VIRTUAL:
+            return "XGL_GPU_TYPE_VIRTUAL";
+        default:
+            return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+    switch ((XGL_IMAGE_LAYOUT)input_value)
+    {
+        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_GENERAL:
+            return "XGL_IMAGE_LAYOUT_GENERAL";
+        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+            return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+        default:
+            return "Unhandled XGL_IMAGE_LAYOUT";
     }
 }
 
@@ -1537,6 +985,438 @@
 }
 
 
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+    switch ((XGL_QUEUE_TYPE)input_value)
+    {
+        case XGL_QUEUE_TYPE_COMPUTE:
+            return "XGL_QUEUE_TYPE_COMPUTE";
+        case XGL_QUEUE_TYPE_DMA:
+            return "XGL_QUEUE_TYPE_DMA";
+        case XGL_QUEUE_TYPE_GRAPHICS:
+            return "XGL_QUEUE_TYPE_GRAPHICS";
+        default:
+            return "Unhandled XGL_QUEUE_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+{
+    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    {
+        case XGL_SHADER_STAGE_FLAGS_ALL:
+            return "XGL_SHADER_STAGE_FLAGS_ALL";
+        case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
+        case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
+        case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
+        case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
+        case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
+        case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+            return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+        default:
+            return "Unhandled XGL_SHADER_STAGE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+    {
+        case XGL_TOPOLOGY_LINE_LIST:
+            return "XGL_TOPOLOGY_LINE_LIST";
+        case XGL_TOPOLOGY_LINE_LIST_ADJ:
+            return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+        case XGL_TOPOLOGY_LINE_STRIP:
+            return "XGL_TOPOLOGY_LINE_STRIP";
+        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+            return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+        case XGL_TOPOLOGY_PATCH:
+            return "XGL_TOPOLOGY_PATCH";
+        case XGL_TOPOLOGY_POINT_LIST:
+            return "XGL_TOPOLOGY_POINT_LIST";
+        case XGL_TOPOLOGY_QUAD_LIST:
+            return "XGL_TOPOLOGY_QUAD_LIST";
+        case XGL_TOPOLOGY_QUAD_STRIP:
+            return "XGL_TOPOLOGY_QUAD_STRIP";
+        case XGL_TOPOLOGY_RECT_LIST:
+            return "XGL_TOPOLOGY_RECT_LIST";
+        case XGL_TOPOLOGY_TRIANGLE_LIST:
+            return "XGL_TOPOLOGY_TRIANGLE_LIST";
+        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+            return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+        case XGL_TOPOLOGY_TRIANGLE_STRIP:
+            return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+            return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+        default:
+            return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+    }
+}
+
+
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+{
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+    {
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+            return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+            return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
+        default:
+            return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+    switch ((XGL_IMAGE_TILING)input_value)
+    {
+        case XGL_LINEAR_TILING:
+            return "XGL_LINEAR_TILING";
+        case XGL_OPTIMAL_TILING:
+            return "XGL_OPTIMAL_TILING";
+        default:
+            return "Unhandled XGL_IMAGE_TILING";
+    }
+}
+
+
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+{
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+    {
+        case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+            return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
+        case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+            return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
+        case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+            return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
+        default:
+            return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
+    }
+}
+
+
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    {
+        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+            return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+            return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+        default:
+            return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+{
+    switch ((XGL_OBJECT_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+            return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+            return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
+        default:
+            return "Unhandled XGL_OBJECT_INFO_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    {
+        case XGL_PROVOKING_VERTEX_FIRST:
+            return "XGL_PROVOKING_VERTEX_FIRST";
+        case XGL_PROVOKING_VERTEX_LAST:
+            return "XGL_PROVOKING_VERTEX_LAST";
+        default:
+            return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
+    }
+}
+
+
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    {
+        case XGL_BUFFER_VIEW_RAW:
+            return "XGL_BUFFER_VIEW_RAW";
+        case XGL_BUFFER_VIEW_STRUCTURED:
+            return "XGL_BUFFER_VIEW_STRUCTURED";
+        case XGL_BUFFER_VIEW_TYPED:
+            return "XGL_BUFFER_VIEW_TYPED";
+        default:
+            return "Unhandled XGL_BUFFER_VIEW_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    {
+        case XGL_DESCRIPTOR_TYPE_IMAGE:
+            return "XGL_DESCRIPTOR_TYPE_IMAGE";
+        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
+        case XGL_DESCRIPTOR_TYPE_SAMPLER:
+            return "XGL_DESCRIPTOR_TYPE_SAMPLER";
+        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+            return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
+        case XGL_DESCRIPTOR_TYPE_TEXTURE:
+            return "XGL_DESCRIPTOR_TYPE_TEXTURE";
+        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+        default:
+            return "Unhandled XGL_DESCRIPTOR_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+    switch ((XGL_IMAGE_TYPE)input_value)
+    {
+        case XGL_IMAGE_1D:
+            return "XGL_IMAGE_1D";
+        case XGL_IMAGE_2D:
+            return "XGL_IMAGE_2D";
+        case XGL_IMAGE_3D:
+            return "XGL_IMAGE_3D";
+        default:
+            return "Unhandled XGL_IMAGE_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+    switch ((XGL_BLEND_FUNC)input_value)
+    {
+        case XGL_BLEND_FUNC_ADD:
+            return "XGL_BLEND_FUNC_ADD";
+        case XGL_BLEND_FUNC_MAX:
+            return "XGL_BLEND_FUNC_MAX";
+        case XGL_BLEND_FUNC_MIN:
+            return "XGL_BLEND_FUNC_MIN";
+        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+            return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+        case XGL_BLEND_FUNC_SUBTRACT:
+            return "XGL_BLEND_FUNC_SUBTRACT";
+        default:
+            return "Unhandled XGL_BLEND_FUNC";
+    }
+}
+
+
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+{
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    {
+        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+            return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+            return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+            return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+            return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+            return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+        default:
+            return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+    switch ((XGL_MEMORY_PRIORITY)input_value)
+    {
+        case XGL_MEMORY_PRIORITY_HIGH:
+            return "XGL_MEMORY_PRIORITY_HIGH";
+        case XGL_MEMORY_PRIORITY_LOW:
+            return "XGL_MEMORY_PRIORITY_LOW";
+        case XGL_MEMORY_PRIORITY_NORMAL:
+            return "XGL_MEMORY_PRIORITY_NORMAL";
+        case XGL_MEMORY_PRIORITY_UNUSED:
+            return "XGL_MEMORY_PRIORITY_UNUSED";
+        case XGL_MEMORY_PRIORITY_VERY_HIGH:
+            return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+        case XGL_MEMORY_PRIORITY_VERY_LOW:
+            return "XGL_MEMORY_PRIORITY_VERY_LOW";
+        default:
+            return "Unhandled XGL_MEMORY_PRIORITY";
+    }
+}
+
+
+static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
+{
+    switch ((XGL_RESULT)input_value)
+    {
+        case XGL_ERROR_BAD_PIPELINE_DATA:
+            return "XGL_ERROR_BAD_PIPELINE_DATA";
+        case XGL_ERROR_BAD_SHADER_CODE:
+            return "XGL_ERROR_BAD_SHADER_CODE";
+        case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+            return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
+        case XGL_ERROR_DEVICE_ALREADY_CREATED:
+            return "XGL_ERROR_DEVICE_ALREADY_CREATED";
+        case XGL_ERROR_DEVICE_LOST:
+            return "XGL_ERROR_DEVICE_LOST";
+        case XGL_ERROR_INCOMPATIBLE_DEVICE:
+            return "XGL_ERROR_INCOMPATIBLE_DEVICE";
+        case XGL_ERROR_INCOMPATIBLE_DRIVER:
+            return "XGL_ERROR_INCOMPATIBLE_DRIVER";
+        case XGL_ERROR_INCOMPATIBLE_QUEUE:
+            return "XGL_ERROR_INCOMPATIBLE_QUEUE";
+        case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+            return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
+        case XGL_ERROR_INITIALIZATION_FAILED:
+            return "XGL_ERROR_INITIALIZATION_FAILED";
+        case XGL_ERROR_INVALID_ALIGNMENT:
+            return "XGL_ERROR_INVALID_ALIGNMENT";
+        case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+            return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
+        case XGL_ERROR_INVALID_EXTENSION:
+            return "XGL_ERROR_INVALID_EXTENSION";
+        case XGL_ERROR_INVALID_FLAGS:
+            return "XGL_ERROR_INVALID_FLAGS";
+        case XGL_ERROR_INVALID_FORMAT:
+            return "XGL_ERROR_INVALID_FORMAT";
+        case XGL_ERROR_INVALID_HANDLE:
+            return "XGL_ERROR_INVALID_HANDLE";
+        case XGL_ERROR_INVALID_IMAGE:
+            return "XGL_ERROR_INVALID_IMAGE";
+        case XGL_ERROR_INVALID_MEMORY_SIZE:
+            return "XGL_ERROR_INVALID_MEMORY_SIZE";
+        case XGL_ERROR_INVALID_OBJECT_TYPE:
+            return "XGL_ERROR_INVALID_OBJECT_TYPE";
+        case XGL_ERROR_INVALID_ORDINAL:
+            return "XGL_ERROR_INVALID_ORDINAL";
+        case XGL_ERROR_INVALID_POINTER:
+            return "XGL_ERROR_INVALID_POINTER";
+        case XGL_ERROR_INVALID_QUEUE_TYPE:
+            return "XGL_ERROR_INVALID_QUEUE_TYPE";
+        case XGL_ERROR_INVALID_VALUE:
+            return "XGL_ERROR_INVALID_VALUE";
+        case XGL_ERROR_MEMORY_MAP_FAILED:
+            return "XGL_ERROR_MEMORY_MAP_FAILED";
+        case XGL_ERROR_MEMORY_NOT_BOUND:
+            return "XGL_ERROR_MEMORY_NOT_BOUND";
+        case XGL_ERROR_MEMORY_UNMAP_FAILED:
+            return "XGL_ERROR_MEMORY_UNMAP_FAILED";
+        case XGL_ERROR_NOT_MAPPABLE:
+            return "XGL_ERROR_NOT_MAPPABLE";
+        case XGL_ERROR_NOT_SHAREABLE:
+            return "XGL_ERROR_NOT_SHAREABLE";
+        case XGL_ERROR_OUT_OF_GPU_MEMORY:
+            return "XGL_ERROR_OUT_OF_GPU_MEMORY";
+        case XGL_ERROR_OUT_OF_MEMORY:
+            return "XGL_ERROR_OUT_OF_MEMORY";
+        case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+            return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
+        case XGL_ERROR_UNAVAILABLE:
+            return "XGL_ERROR_UNAVAILABLE";
+        case XGL_ERROR_UNKNOWN:
+            return "XGL_ERROR_UNKNOWN";
+        case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+            return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
+        case XGL_EVENT_RESET:
+            return "XGL_EVENT_RESET";
+        case XGL_EVENT_SET:
+            return "XGL_EVENT_SET";
+        case XGL_NOT_READY:
+            return "XGL_NOT_READY";
+        case XGL_SUCCESS:
+            return "XGL_SUCCESS";
+        case XGL_TIMEOUT:
+            return "XGL_TIMEOUT";
+        case XGL_UNSUPPORTED:
+            return "XGL_UNSUPPORTED";
+        default:
+            return "Unhandled XGL_RESULT";
+    }
+}
+
+
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+    switch ((XGL_FILL_MODE)input_value)
+    {
+        case XGL_FILL_POINTS:
+            return "XGL_FILL_POINTS";
+        case XGL_FILL_SOLID:
+            return "XGL_FILL_SOLID";
+        case XGL_FILL_WIREFRAME:
+            return "XGL_FILL_WIREFRAME";
+        default:
+            return "Unhandled XGL_FILL_MODE";
+    }
+}
+
+
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+    switch ((XGL_TEX_FILTER)input_value)
+    {
+        case XGL_TEX_FILTER_LINEAR:
+            return "XGL_TEX_FILTER_LINEAR";
+        case XGL_TEX_FILTER_NEAREST:
+            return "XGL_TEX_FILTER_NEAREST";
+        default:
+            return "Unhandled XGL_TEX_FILTER";
+    }
+}
+
+
+static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+{
+    switch ((XGL_QUERY_TYPE)input_value)
+    {
+        case XGL_QUERY_OCCLUSION:
+            return "XGL_QUERY_OCCLUSION";
+        case XGL_QUERY_PIPELINE_STATISTICS:
+            return "XGL_QUERY_PIPELINE_STATISTICS";
+        default:
+            return "Unhandled XGL_QUERY_TYPE";
+    }
+}
+
+
 static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
 {
     switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
@@ -1567,274 +1447,32 @@
 }
 
 
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-            return "XGL_TEX_FILTER_LINEAR";
-        case XGL_TEX_FILTER_NEAREST:
-            return "XGL_TEX_FILTER_NEAREST";
+        case XGL_TIMESTAMP_BOTTOM:
+            return "XGL_TIMESTAMP_BOTTOM";
+        case XGL_TIMESTAMP_TOP:
+            return "XGL_TIMESTAMP_TOP";
         default:
-            return "Unhandled XGL_TEX_FILTER";
+            return "Unhandled XGL_TIMESTAMP_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
 {
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    switch ((XGL_BORDER_COLOR_TYPE)input_value)
     {
-        case XGL_SHADER_STAGE_COMPUTE:
-            return "XGL_SHADER_STAGE_COMPUTE";
-        case XGL_SHADER_STAGE_FRAGMENT:
-            return "XGL_SHADER_STAGE_FRAGMENT";
-        case XGL_SHADER_STAGE_GEOMETRY:
-            return "XGL_SHADER_STAGE_GEOMETRY";
-        case XGL_SHADER_STAGE_TESS_CONTROL:
-            return "XGL_SHADER_STAGE_TESS_CONTROL";
-        case XGL_SHADER_STAGE_TESS_EVALUATION:
-            return "XGL_SHADER_STAGE_TESS_EVALUATION";
-        case XGL_SHADER_STAGE_VERTEX:
-            return "XGL_SHADER_STAGE_VERTEX";
+        case XGL_BORDER_COLOR_OPAQUE_BLACK:
+            return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+        case XGL_BORDER_COLOR_OPAQUE_WHITE:
+            return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+            return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
         default:
-            return "Unhandled XGL_PIPELINE_SHADER_STAGE";
-    }
-}
-
-
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
-    switch ((XGL_BLEND_FUNC)input_value)
-    {
-        case XGL_BLEND_FUNC_ADD:
-            return "XGL_BLEND_FUNC_ADD";
-        case XGL_BLEND_FUNC_MAX:
-            return "XGL_BLEND_FUNC_MAX";
-        case XGL_BLEND_FUNC_MIN:
-            return "XGL_BLEND_FUNC_MIN";
-        case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
-            return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
-        case XGL_BLEND_FUNC_SUBTRACT:
-            return "XGL_BLEND_FUNC_SUBTRACT";
-        default:
-            return "Unhandled XGL_BLEND_FUNC";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
-    switch ((XGL_IMAGE_LAYOUT)input_value)
-    {
-        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_GENERAL:
-            return "XGL_IMAGE_LAYOUT_GENERAL";
-        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
-        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
-            return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
-        default:
-            return "Unhandled XGL_IMAGE_LAYOUT";
-    }
-}
-
-
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
-    {
-        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
-            return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
-        case XGL_BUFFER_CREATE_SPARSE_BIT:
-            return "XGL_BUFFER_CREATE_SPARSE_BIT";
-        default:
-            return "Unhandled XGL_BUFFER_CREATE_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
-{
-    switch ((XGL_MEMORY_TYPE)input_value)
-    {
-        case XGL_MEMORY_TYPE_BUFFER:
-            return "XGL_MEMORY_TYPE_BUFFER";
-        case XGL_MEMORY_TYPE_IMAGE:
-            return "XGL_MEMORY_TYPE_IMAGE";
-        case XGL_MEMORY_TYPE_OTHER:
-            return "XGL_MEMORY_TYPE_OTHER";
-        default:
-            return "Unhandled XGL_MEMORY_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
-{
-    switch ((XGL_QUEUE_TYPE)input_value)
-    {
-        case XGL_QUEUE_TYPE_COMPUTE:
-            return "XGL_QUEUE_TYPE_COMPUTE";
-        case XGL_QUEUE_TYPE_DMA:
-            return "XGL_QUEUE_TYPE_DMA";
-        case XGL_QUEUE_TYPE_GRAPHICS:
-            return "XGL_QUEUE_TYPE_GRAPHICS";
-        default:
-            return "Unhandled XGL_QUEUE_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
-{
-    switch ((XGL_IMAGE_TILING)input_value)
-    {
-        case XGL_LINEAR_TILING:
-            return "XGL_LINEAR_TILING";
-        case XGL_OPTIMAL_TILING:
-            return "XGL_OPTIMAL_TILING";
-        default:
-            return "Unhandled XGL_IMAGE_TILING";
-    }
-}
-
-
-static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
-    {
-        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
-        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
-            return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
-        default:
-            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
-{
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
-            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
-        default:
-            return "Unhandled XGL_FORMAT_INFO_TYPE";
-    }
-}
-
-
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
-    switch ((XGL_STATE_BIND_POINT)input_value)
-    {
-        case XGL_STATE_BIND_COLOR_BLEND:
-            return "XGL_STATE_BIND_COLOR_BLEND";
-        case XGL_STATE_BIND_DEPTH_STENCIL:
-            return "XGL_STATE_BIND_DEPTH_STENCIL";
-        case XGL_STATE_BIND_RASTER:
-            return "XGL_STATE_BIND_RASTER";
-        case XGL_STATE_BIND_VIEWPORT:
-            return "XGL_STATE_BIND_VIEWPORT";
-        default:
-            return "Unhandled XGL_STATE_BIND_POINT";
-    }
-}
-
-
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
-{
-    switch ((XGL_TEX_ADDRESS)input_value)
-    {
-        case XGL_TEX_ADDRESS_CLAMP:
-            return "XGL_TEX_ADDRESS_CLAMP";
-        case XGL_TEX_ADDRESS_CLAMP_BORDER:
-            return "XGL_TEX_ADDRESS_CLAMP_BORDER";
-        case XGL_TEX_ADDRESS_MIRROR:
-            return "XGL_TEX_ADDRESS_MIRROR";
-        case XGL_TEX_ADDRESS_MIRROR_ONCE:
-            return "XGL_TEX_ADDRESS_MIRROR_ONCE";
-        case XGL_TEX_ADDRESS_WRAP:
-            return "XGL_TEX_ADDRESS_WRAP";
-        default:
-            return "Unhandled XGL_TEX_ADDRESS";
-    }
-}
-
-
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
-{
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
-    {
-        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
-            return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
-        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
-            return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
-        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
-            return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
-        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
-        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
-        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
-            return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
-        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
-            return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
-        default:
-            return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
-    }
-}
-
-
-static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
-{
-    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
-    {
-        case XGL_BUFFER_USAGE_GENERAL:
-            return "XGL_BUFFER_USAGE_GENERAL";
-        case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
-            return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
-        case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
-            return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
-        case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
-            return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
-        case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
-            return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-            return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
-            return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
-        case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
-            return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
-        case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
-            return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
-        case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
-            return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
-        case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
-            return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
-        case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
-            return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
-        case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
-            return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
-        case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
-            return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
-        default:
-            return "Unhandled XGL_BUFFER_USAGE_FLAGS";
+            return "Unhandled XGL_BORDER_COLOR_TYPE";
     }
 }
 
@@ -1880,3 +1518,365 @@
     }
 }
 
+
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    {
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
+            return "XGL_QUERY_IMPRECISE_DATA_BIT";
+        default:
+            return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+{
+    switch ((XGL_IMAGE_ASPECT)input_value)
+    {
+        case XGL_IMAGE_ASPECT_COLOR:
+            return "XGL_IMAGE_ASPECT_COLOR";
+        case XGL_IMAGE_ASPECT_DEPTH:
+            return "XGL_IMAGE_ASPECT_DEPTH";
+        case XGL_IMAGE_ASPECT_STENCIL:
+            return "XGL_IMAGE_ASPECT_STENCIL";
+        default:
+            return "Unhandled XGL_IMAGE_ASPECT";
+    }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    {
+        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+            return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+            return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+            return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+        default:
+            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+{
+    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+    {
+        case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+            return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
+        case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+            return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
+        case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+            return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
+        case XGL_IMAGE_FORMAT_CLASS_D16:
+            return "XGL_IMAGE_FORMAT_CLASS_D16";
+        case XGL_IMAGE_FORMAT_CLASS_D16S8:
+            return "XGL_IMAGE_FORMAT_CLASS_D16S8";
+        case XGL_IMAGE_FORMAT_CLASS_D24:
+            return "XGL_IMAGE_FORMAT_CLASS_D24";
+        case XGL_IMAGE_FORMAT_CLASS_D24S8:
+            return "XGL_IMAGE_FORMAT_CLASS_D24S8";
+        case XGL_IMAGE_FORMAT_CLASS_D32:
+            return "XGL_IMAGE_FORMAT_CLASS_D32";
+        case XGL_IMAGE_FORMAT_CLASS_D32S8:
+            return "XGL_IMAGE_FORMAT_CLASS_D32S8";
+        case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+            return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
+        case XGL_IMAGE_FORMAT_CLASS_S8:
+            return "XGL_IMAGE_FORMAT_CLASS_S8";
+        default:
+            return "Unhandled XGL_IMAGE_FORMAT_CLASS";
+    }
+}
+
+
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+{
+    switch ((XGL_TEX_ADDRESS)input_value)
+    {
+        case XGL_TEX_ADDRESS_CLAMP:
+            return "XGL_TEX_ADDRESS_CLAMP";
+        case XGL_TEX_ADDRESS_CLAMP_BORDER:
+            return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+        case XGL_TEX_ADDRESS_MIRROR:
+            return "XGL_TEX_ADDRESS_MIRROR";
+        case XGL_TEX_ADDRESS_MIRROR_ONCE:
+            return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+        case XGL_TEX_ADDRESS_WRAP:
+            return "XGL_TEX_ADDRESS_WRAP";
+        default:
+            return "Unhandled XGL_TEX_ADDRESS";
+    }
+}
+
+
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+{
+    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    {
+        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+            return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
+        default:
+            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+    switch ((XGL_INDEX_TYPE)input_value)
+    {
+        case XGL_INDEX_16:
+            return "XGL_INDEX_16";
+        case XGL_INDEX_32:
+            return "XGL_INDEX_32";
+        case XGL_INDEX_8:
+            return "XGL_INDEX_8";
+        default:
+            return "Unhandled XGL_INDEX_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+    switch ((XGL_COMPARE_FUNC)input_value)
+    {
+        case XGL_COMPARE_ALWAYS:
+            return "XGL_COMPARE_ALWAYS";
+        case XGL_COMPARE_EQUAL:
+            return "XGL_COMPARE_EQUAL";
+        case XGL_COMPARE_GREATER:
+            return "XGL_COMPARE_GREATER";
+        case XGL_COMPARE_GREATER_EQUAL:
+            return "XGL_COMPARE_GREATER_EQUAL";
+        case XGL_COMPARE_LESS:
+            return "XGL_COMPARE_LESS";
+        case XGL_COMPARE_LESS_EQUAL:
+            return "XGL_COMPARE_LESS_EQUAL";
+        case XGL_COMPARE_NEVER:
+            return "XGL_COMPARE_NEVER";
+        case XGL_COMPARE_NOT_EQUAL:
+            return "XGL_COMPARE_NOT_EQUAL";
+        default:
+            return "Unhandled XGL_COMPARE_FUNC";
+    }
+}
+
+
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+{
+    switch ((XGL_STATE_BIND_POINT)input_value)
+    {
+        case XGL_STATE_BIND_COLOR_BLEND:
+            return "XGL_STATE_BIND_COLOR_BLEND";
+        case XGL_STATE_BIND_DEPTH_STENCIL:
+            return "XGL_STATE_BIND_DEPTH_STENCIL";
+        case XGL_STATE_BIND_RASTER:
+            return "XGL_STATE_BIND_RASTER";
+        case XGL_STATE_BIND_VIEWPORT:
+            return "XGL_STATE_BIND_VIEWPORT";
+        default:
+            return "Unhandled XGL_STATE_BIND_POINT";
+    }
+}
+
+
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+    switch ((XGL_STENCIL_OP)input_value)
+    {
+        case XGL_STENCIL_OP_DEC_CLAMP:
+            return "XGL_STENCIL_OP_DEC_CLAMP";
+        case XGL_STENCIL_OP_DEC_WRAP:
+            return "XGL_STENCIL_OP_DEC_WRAP";
+        case XGL_STENCIL_OP_INC_CLAMP:
+            return "XGL_STENCIL_OP_INC_CLAMP";
+        case XGL_STENCIL_OP_INC_WRAP:
+            return "XGL_STENCIL_OP_INC_WRAP";
+        case XGL_STENCIL_OP_INVERT:
+            return "XGL_STENCIL_OP_INVERT";
+        case XGL_STENCIL_OP_KEEP:
+            return "XGL_STENCIL_OP_KEEP";
+        case XGL_STENCIL_OP_REPLACE:
+            return "XGL_STENCIL_OP_REPLACE";
+        case XGL_STENCIL_OP_ZERO:
+            return "XGL_STENCIL_OP_ZERO";
+        default:
+            return "Unhandled XGL_STENCIL_OP";
+    }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+            return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
+        default:
+            return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    {
+        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+            return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+            return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+            return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+            return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+        case XGL_IMAGE_CREATE_SPARSE_BIT:
+            return "XGL_IMAGE_CREATE_SPARSE_BIT";
+        default:
+            return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    {
+        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+            return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
+        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+            return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
+        case XGL_ATTACHMENT_STORE_OP_STORE:
+            return "XGL_ATTACHMENT_STORE_OP_STORE";
+        default:
+            return "Unhandled XGL_ATTACHMENT_STORE_OP";
+    }
+}
+
+
+static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+{
+    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+    {
+        case XGL_BUFFER_USAGE_GENERAL:
+            return "XGL_BUFFER_USAGE_GENERAL";
+        case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
+            return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
+        case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
+            return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
+        case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
+            return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
+        case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
+            return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+            return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
+            return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
+        case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
+            return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
+        case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
+            return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
+        case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
+            return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
+        case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
+            return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
+        case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
+            return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
+        case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
+            return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
+        case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
+            return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
+        default:
+            return "Unhandled XGL_BUFFER_USAGE_FLAGS";
+    }
+}
+
+
+static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+{
+    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+    {
+        case XGL_IMAGE_VIEW_1D:
+            return "XGL_IMAGE_VIEW_1D";
+        case XGL_IMAGE_VIEW_2D:
+            return "XGL_IMAGE_VIEW_2D";
+        case XGL_IMAGE_VIEW_3D:
+            return "XGL_IMAGE_VIEW_3D";
+        case XGL_IMAGE_VIEW_CUBE:
+            return "XGL_IMAGE_VIEW_CUBE";
+        default:
+            return "Unhandled XGL_IMAGE_VIEW_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+        default:
+            return "Unhandled XGL_FORMAT_INFO_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+        default:
+            return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+    }
+}
+
+
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+    switch ((XGL_FACE_ORIENTATION)input_value)
+    {
+        case XGL_FRONT_FACE_CCW:
+            return "XGL_FRONT_FACE_CCW";
+        case XGL_FRONT_FACE_CW:
+            return "XGL_FRONT_FACE_CW";
+        default:
+            return "Unhandled XGL_FACE_ORIENTATION";
+    }
+}
+
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h
index 27df254..4a0f032 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h
@@ -3,53 +3,6 @@
 #include <xgl.h>
 
 
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
-    switch ((XGL_STENCIL_OP)input_value)
-    {
-        case XGL_STENCIL_OP_DEC_CLAMP:
-        case XGL_STENCIL_OP_DEC_WRAP:
-        case XGL_STENCIL_OP_INC_CLAMP:
-        case XGL_STENCIL_OP_INC_WRAP:
-        case XGL_STENCIL_OP_INVERT:
-        case XGL_STENCIL_OP_KEEP:
-        case XGL_STENCIL_OP_REPLACE:
-        case XGL_STENCIL_OP_ZERO:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
-    {
-        case XGL_SYSTEM_ALLOC_API_OBJECT:
-        case XGL_SYSTEM_ALLOC_DEBUG:
-        case XGL_SYSTEM_ALLOC_INTERNAL:
-        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
-        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
-    {
-        case XGL_MEMORY_REF_READ_ONLY_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
 static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
 {
     switch ((XGL_PIPELINE_BIND_POINT)input_value)
@@ -63,15 +16,16 @@
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
     {
-        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
-        case XGL_MEMORY_OUTPUT_COPY_BIT:
-        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
-        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+        case XGL_SHADER_STAGE_COMPUTE:
+        case XGL_SHADER_STAGE_FRAGMENT:
+        case XGL_SHADER_STAGE_GEOMETRY:
+        case XGL_SHADER_STAGE_TESS_CONTROL:
+        case XGL_SHADER_STAGE_TESS_EVALUATION:
+        case XGL_SHADER_STAGE_VERTEX:
             return 1;
         default:
             return 0;
@@ -79,13 +33,11 @@
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
     {
-        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
-        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
-        case XGL_ATTACHMENT_STORE_OP_STORE:
+        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
             return 1;
         default:
             return 0;
@@ -93,14 +45,13 @@
 }
 
 
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
 {
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
+    switch ((XGL_MEMORY_TYPE)input_value)
     {
-        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
-        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
-        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
-        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+        case XGL_MEMORY_TYPE_BUFFER:
+        case XGL_MEMORY_TYPE_IMAGE:
+        case XGL_MEMORY_TYPE_OTHER:
             return 1;
         default:
             return 0;
@@ -125,719 +76,12 @@
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+    switch ((XGL_DEPTH_MODE)input_value)
     {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
-{
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
-    {
-        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
-        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
-{
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
-    {
-        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
-        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
-        case XGL_IMAGE_USAGE_GENERAL:
-        case XGL_IMAGE_USAGE_IMAGE_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
-        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
-        case XGL_IMAGE_USAGE_TEXTURE_BIT:
-        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
-        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
-{
-    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
-    {
-        case XGL_IMAGE_FORMAT_CLASS_128_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
-        case XGL_IMAGE_FORMAT_CLASS_16_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_24_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_32_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_48_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_64_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
-        case XGL_IMAGE_FORMAT_CLASS_8_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_96_BITS:
-        case XGL_IMAGE_FORMAT_CLASS_D16:
-        case XGL_IMAGE_FORMAT_CLASS_D16S8:
-        case XGL_IMAGE_FORMAT_CLASS_D24:
-        case XGL_IMAGE_FORMAT_CLASS_D24S8:
-        case XGL_IMAGE_FORMAT_CLASS_D32:
-        case XGL_IMAGE_FORMAT_CLASS_D32S8:
-        case XGL_IMAGE_FORMAT_CLASS_LINEAR:
-        case XGL_IMAGE_FORMAT_CLASS_S8:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
-    switch ((XGL_QUERY_TYPE)input_value)
-    {
-        case XGL_QUERY_OCCLUSION:
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
-    switch ((XGL_STRUCTURE_TYPE)input_value)
-    {
-        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
-        case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
-        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
-        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
-        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
-        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
-        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
-        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
-        case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
-        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
-        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
-        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
-        case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
-        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
-        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
-        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
-        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
-    {
-        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
-        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
-        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
-        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
-        case XGL_IMAGE_CREATE_SPARSE_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
-    {
-        case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
-        case XGL_MEMORY_INPUT_COPY_BIT:
-        case XGL_MEMORY_INPUT_CPU_READ_BIT:
-        case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
-        case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
-        case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
-        case XGL_MEMORY_INPUT_SHADER_READ_BIT:
-        case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
-        case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
-    switch ((XGL_IMAGE_ASPECT)input_value)
-    {
-        case XGL_IMAGE_ASPECT_COLOR:
-        case XGL_IMAGE_ASPECT_DEPTH:
-        case XGL_IMAGE_ASPECT_STENCIL:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
-    {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
-    switch ((XGL_COMPARE_FUNC)input_value)
-    {
-        case XGL_COMPARE_ALWAYS:
-        case XGL_COMPARE_EQUAL:
-        case XGL_COMPARE_GREATER:
-        case XGL_COMPARE_GREATER_EQUAL:
-        case XGL_COMPARE_LESS:
-        case XGL_COMPARE_LESS_EQUAL:
-        case XGL_COMPARE_NEVER:
-        case XGL_COMPARE_NOT_EQUAL:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
-{
-    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
-    {
-        case XGL_SHADER_STAGE_FLAGS_ALL:
-        case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
-        case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
-        case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
-        case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
-        case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
-        case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
-    switch ((XGL_FILL_MODE)input_value)
-    {
-        case XGL_FILL_POINTS:
-        case XGL_FILL_SOLID:
-        case XGL_FILL_WIREFRAME:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
-    switch ((XGL_COORDINATE_ORIGIN)input_value)
-    {
-        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
-        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
-    switch ((XGL_WAIT_EVENT)input_value)
-    {
-        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
-        case XGL_WAIT_EVENT_TOP_OF_PIPE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
-    {
-        case XGL_DESCRIPTOR_TYPE_IMAGE:
-        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
-        case XGL_DESCRIPTOR_TYPE_SAMPLER:
-        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
-        case XGL_DESCRIPTOR_TYPE_TEXTURE:
-        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
-    {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
-    switch ((XGL_MEMORY_PRIORITY)input_value)
-    {
-        case XGL_MEMORY_PRIORITY_HIGH:
-        case XGL_MEMORY_PRIORITY_LOW:
-        case XGL_MEMORY_PRIORITY_NORMAL:
-        case XGL_MEMORY_PRIORITY_UNUSED:
-        case XGL_MEMORY_PRIORITY_VERY_HIGH:
-        case XGL_MEMORY_PRIORITY_VERY_LOW:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
-    {
-        case XGL_TIMESTAMP_BOTTOM:
-        case XGL_TIMESTAMP_TOP:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
-    {
-        case XGL_GPU_TYPE_DISCRETE:
-        case XGL_GPU_TYPE_INTEGRATED:
-        case XGL_GPU_TYPE_OTHER:
-        case XGL_GPU_TYPE_VIRTUAL:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
-{
-    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
-    {
-        case XGL_TOPOLOGY_LINE_LIST:
-        case XGL_TOPOLOGY_LINE_LIST_ADJ:
-        case XGL_TOPOLOGY_LINE_STRIP:
-        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
-        case XGL_TOPOLOGY_PATCH:
-        case XGL_TOPOLOGY_POINT_LIST:
-        case XGL_TOPOLOGY_QUAD_LIST:
-        case XGL_TOPOLOGY_QUAD_STRIP:
-        case XGL_TOPOLOGY_RECT_LIST:
-        case XGL_TOPOLOGY_TRIANGLE_LIST:
-        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
-        case XGL_TOPOLOGY_TRIANGLE_STRIP:
-        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
-    {
-        case XGL_IMAGE_VIEW_1D:
-        case XGL_IMAGE_VIEW_2D:
-        case XGL_IMAGE_VIEW_3D:
-        case XGL_IMAGE_VIEW_CUBE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
-    {
-        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
-        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
-{
-    switch ((XGL_RESULT)input_value)
-    {
-        case XGL_ERROR_BAD_PIPELINE_DATA:
-        case XGL_ERROR_BAD_SHADER_CODE:
-        case XGL_ERROR_BUILDING_COMMAND_BUFFER:
-        case XGL_ERROR_DEVICE_ALREADY_CREATED:
-        case XGL_ERROR_DEVICE_LOST:
-        case XGL_ERROR_INCOMPATIBLE_DEVICE:
-        case XGL_ERROR_INCOMPATIBLE_DRIVER:
-        case XGL_ERROR_INCOMPATIBLE_QUEUE:
-        case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
-        case XGL_ERROR_INITIALIZATION_FAILED:
-        case XGL_ERROR_INVALID_ALIGNMENT:
-        case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
-        case XGL_ERROR_INVALID_EXTENSION:
-        case XGL_ERROR_INVALID_FLAGS:
-        case XGL_ERROR_INVALID_FORMAT:
-        case XGL_ERROR_INVALID_HANDLE:
-        case XGL_ERROR_INVALID_IMAGE:
-        case XGL_ERROR_INVALID_MEMORY_SIZE:
-        case XGL_ERROR_INVALID_OBJECT_TYPE:
-        case XGL_ERROR_INVALID_ORDINAL:
-        case XGL_ERROR_INVALID_POINTER:
-        case XGL_ERROR_INVALID_QUEUE_TYPE:
-        case XGL_ERROR_INVALID_VALUE:
-        case XGL_ERROR_MEMORY_MAP_FAILED:
-        case XGL_ERROR_MEMORY_NOT_BOUND:
-        case XGL_ERROR_MEMORY_UNMAP_FAILED:
-        case XGL_ERROR_NOT_MAPPABLE:
-        case XGL_ERROR_NOT_SHAREABLE:
-        case XGL_ERROR_OUT_OF_GPU_MEMORY:
-        case XGL_ERROR_OUT_OF_MEMORY:
-        case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
-        case XGL_ERROR_UNAVAILABLE:
-        case XGL_ERROR_UNKNOWN:
-        case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
-        case XGL_EVENT_RESET:
-        case XGL_EVENT_SET:
-        case XGL_NOT_READY:
-        case XGL_SUCCESS:
-        case XGL_TIMEOUT:
-        case XGL_UNSUPPORTED:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
-    {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
-    {
-        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
-        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
-    {
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
-    switch ((XGL_INDEX_TYPE)input_value)
-    {
-        case XGL_INDEX_16:
-        case XGL_INDEX_32:
-        case XGL_INDEX_8:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
-    switch ((XGL_CULL_MODE)input_value)
-    {
-        case XGL_CULL_BACK:
-        case XGL_CULL_FRONT:
-        case XGL_CULL_FRONT_AND_BACK:
-        case XGL_CULL_NONE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
-    switch ((XGL_SET_EVENT)input_value)
-    {
-        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
-        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
-        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
-        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
-        case XGL_SET_EVENT_TOP_OF_PIPE:
-        case XGL_SET_EVENT_TRANSFER_COMPLETE:
-        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
-{
-    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
-    {
-        case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
-        case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
-        case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
-        case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
-        case XGL_MEMORY_PROPERTY_GPU_ONLY:
-        case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
-        case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
-{
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
-    {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
-    {
-        case XGL_PROVOKING_VERTEX_FIRST:
-        case XGL_PROVOKING_VERTEX_LAST:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
-    switch ((XGL_VALIDATION_LEVEL)input_value)
-    {
-        case XGL_VALIDATION_LEVEL_0:
-        case XGL_VALIDATION_LEVEL_1:
-        case XGL_VALIDATION_LEVEL_2:
-        case XGL_VALIDATION_LEVEL_3:
-        case XGL_VALIDATION_LEVEL_4:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
-    switch ((XGL_FACE_ORIENTATION)input_value)
-    {
-        case XGL_FRONT_FACE_CCW:
-        case XGL_FRONT_FACE_CW:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
-{
-    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
-    {
-        case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
-        case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
-        case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
-    switch ((XGL_QUEUE_FLAGS)input_value)
-    {
-        case XGL_QUEUE_COMPUTE_BIT:
-        case XGL_QUEUE_DMA_BIT:
-        case XGL_QUEUE_EXTENDED_BIT:
-        case XGL_QUEUE_GRAPHICS_BIT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
-    {
-        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
-        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
-    {
-        case XGL_TEX_MIPMAP_BASE:
-        case XGL_TEX_MIPMAP_LINEAR:
-        case XGL_TEX_MIPMAP_NEAREST:
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
-    {
-        case XGL_QUERY_IMPRECISE_DATA_BIT:
+        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+        case XGL_DEPTH_MODE_ZERO_TO_ONE:
             return 1;
         default:
             return 0;
@@ -1023,12 +267,12 @@
 }
 
 
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
 {
-    switch ((XGL_DEPTH_MODE)input_value)
+    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
     {
-        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
-        case XGL_DEPTH_MODE_ZERO_TO_ONE:
+        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+        case XGL_BUFFER_CREATE_SPARSE_BIT:
             return 1;
         default:
             return 0;
@@ -1036,13 +280,17 @@
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
 {
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
     {
-        case XGL_BUFFER_VIEW_RAW:
-        case XGL_BUFFER_VIEW_STRUCTURED:
-        case XGL_BUFFER_VIEW_TYPED:
+        case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+        case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+        case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+        case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+        case XGL_MEMORY_PROPERTY_GPU_ONLY:
+        case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+        case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
             return 1;
         default:
             return 0;
@@ -1050,13 +298,339 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
     {
-        case XGL_IMAGE_1D:
-        case XGL_IMAGE_2D:
-        case XGL_IMAGE_3D:
+        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+    switch ((XGL_COORDINATE_ORIGIN)input_value)
+    {
+        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+    switch ((XGL_CULL_MODE)input_value)
+    {
+        case XGL_CULL_BACK:
+        case XGL_CULL_FRONT:
+        case XGL_CULL_FRONT_AND_BACK:
+        case XGL_CULL_NONE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+{
+    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+    {
+        case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+        case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+        case XGL_IMAGE_USAGE_GENERAL:
+        case XGL_IMAGE_USAGE_IMAGE_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+        case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+        case XGL_IMAGE_USAGE_TEXTURE_BIT:
+        case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+        case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    {
+        case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+        case XGL_MEMORY_OUTPUT_COPY_BIT:
+        case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+        case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+        case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+    switch ((XGL_SET_EVENT)input_value)
+    {
+        case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+        case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+        case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+        case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+        case XGL_SET_EVENT_TOP_OF_PIPE:
+        case XGL_SET_EVENT_TRANSFER_COMPLETE:
+        case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+    {
+        case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+        case XGL_MEMORY_INPUT_COPY_BIT:
+        case XGL_MEMORY_INPUT_CPU_READ_BIT:
+        case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+        case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+        case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+        case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+        case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+        case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+{
+    switch ((XGL_TEX_MIPMAP_MODE)input_value)
+    {
+        case XGL_TEX_MIPMAP_BASE:
+        case XGL_TEX_MIPMAP_LINEAR:
+        case XGL_TEX_MIPMAP_NEAREST:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    {
+        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+    switch ((XGL_STRUCTURE_TYPE)input_value)
+    {
+        case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+        case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+        case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+        case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+        case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+        case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+        case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+        case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+        case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+        case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+        case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+        case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+        case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+        case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+        case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+        case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+    switch ((XGL_MEMORY_REF_FLAGS)input_value)
+    {
+        case XGL_MEMORY_REF_READ_ONLY_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    {
+        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    {
+        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+    switch ((XGL_WAIT_EVENT)input_value)
+    {
+        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+        case XGL_WAIT_EVENT_TOP_OF_PIPE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+{
+    switch ((XGL_QUEUE_FLAGS)input_value)
+    {
+        case XGL_QUEUE_COMPUTE_BIT:
+        case XGL_QUEUE_DMA_BIT:
+        case XGL_QUEUE_EXTENDED_BIT:
+        case XGL_QUEUE_GRAPHICS_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+{
+    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+    {
+        case XGL_SYSTEM_ALLOC_API_OBJECT:
+        case XGL_SYSTEM_ALLOC_DEBUG:
+        case XGL_SYSTEM_ALLOC_INTERNAL:
+        case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+        case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+{
+    switch ((XGL_VALIDATION_LEVEL)input_value)
+    {
+        case XGL_VALIDATION_LEVEL_0:
+        case XGL_VALIDATION_LEVEL_1:
+        case XGL_VALIDATION_LEVEL_2:
+        case XGL_VALIDATION_LEVEL_3:
+        case XGL_VALIDATION_LEVEL_4:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    {
+        case XGL_GPU_TYPE_DISCRETE:
+        case XGL_GPU_TYPE_INTEGRATED:
+        case XGL_GPU_TYPE_OTHER:
+        case XGL_GPU_TYPE_VIRTUAL:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+    switch ((XGL_IMAGE_LAYOUT)input_value)
+    {
+        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_GENERAL:
+        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
             return 1;
         default:
             return 0;
@@ -1094,20 +668,13 @@
 }
 
 
-static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
 {
-    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+    switch ((XGL_QUEUE_TYPE)input_value)
     {
-        case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
-        case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
-        case XGL_FORMAT_CONVERSION_BIT:
-        case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
-        case XGL_FORMAT_IMAGE_COPY_BIT:
-        case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
-        case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
-        case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
-        case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
-        case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+        case XGL_QUEUE_TYPE_COMPUTE:
+        case XGL_QUEUE_TYPE_DMA:
+        case XGL_QUEUE_TYPE_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -1115,12 +682,17 @@
 }
 
 
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-        case XGL_TEX_FILTER_NEAREST:
+        case XGL_SHADER_STAGE_FLAGS_ALL:
+        case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+        case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+        case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+        case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+        case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+        case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
             return 1;
         default:
             return 0;
@@ -1128,16 +700,155 @@
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
 {
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
     {
-        case XGL_SHADER_STAGE_COMPUTE:
-        case XGL_SHADER_STAGE_FRAGMENT:
-        case XGL_SHADER_STAGE_GEOMETRY:
-        case XGL_SHADER_STAGE_TESS_CONTROL:
-        case XGL_SHADER_STAGE_TESS_EVALUATION:
-        case XGL_SHADER_STAGE_VERTEX:
+        case XGL_TOPOLOGY_LINE_LIST:
+        case XGL_TOPOLOGY_LINE_LIST_ADJ:
+        case XGL_TOPOLOGY_LINE_STRIP:
+        case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+        case XGL_TOPOLOGY_PATCH:
+        case XGL_TOPOLOGY_POINT_LIST:
+        case XGL_TOPOLOGY_QUAD_LIST:
+        case XGL_TOPOLOGY_QUAD_STRIP:
+        case XGL_TOPOLOGY_RECT_LIST:
+        case XGL_TOPOLOGY_TRIANGLE_LIST:
+        case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+        case XGL_TOPOLOGY_TRIANGLE_STRIP:
+        case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+{
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+    {
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+    switch ((XGL_IMAGE_TILING)input_value)
+    {
+        case XGL_LINEAR_TILING:
+        case XGL_OPTIMAL_TILING:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+{
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+    {
+        case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+        case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+        case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    {
+        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+{
+    switch ((XGL_OBJECT_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+        case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+        case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+        case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    {
+        case XGL_PROVOKING_VERTEX_FIRST:
+        case XGL_PROVOKING_VERTEX_LAST:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    {
+        case XGL_BUFFER_VIEW_RAW:
+        case XGL_BUFFER_VIEW_STRUCTURED:
+        case XGL_BUFFER_VIEW_TYPED:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    {
+        case XGL_DESCRIPTOR_TYPE_IMAGE:
+        case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+        case XGL_DESCRIPTOR_TYPE_SAMPLER:
+        case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+        case XGL_DESCRIPTOR_TYPE_TEXTURE:
+        case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+    switch ((XGL_IMAGE_TYPE)input_value)
+    {
+        case XGL_IMAGE_1D:
+        case XGL_IMAGE_2D:
+        case XGL_IMAGE_3D:
             return 1;
         default:
             return 0;
@@ -1161,18 +872,17 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_LAYOUT)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
     {
-        case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_GENERAL:
-        case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
-        case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
             return 1;
         default:
             return 0;
@@ -1180,12 +890,16 @@
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
 {
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+    switch ((XGL_MEMORY_PRIORITY)input_value)
     {
-        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
-        case XGL_BUFFER_CREATE_SPARSE_BIT:
+        case XGL_MEMORY_PRIORITY_HIGH:
+        case XGL_MEMORY_PRIORITY_LOW:
+        case XGL_MEMORY_PRIORITY_NORMAL:
+        case XGL_MEMORY_PRIORITY_UNUSED:
+        case XGL_MEMORY_PRIORITY_VERY_HIGH:
+        case XGL_MEMORY_PRIORITY_VERY_LOW:
             return 1;
         default:
             return 0;
@@ -1193,13 +907,50 @@
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
 {
-    switch ((XGL_MEMORY_TYPE)input_value)
+    switch ((XGL_RESULT)input_value)
     {
-        case XGL_MEMORY_TYPE_BUFFER:
-        case XGL_MEMORY_TYPE_IMAGE:
-        case XGL_MEMORY_TYPE_OTHER:
+        case XGL_ERROR_BAD_PIPELINE_DATA:
+        case XGL_ERROR_BAD_SHADER_CODE:
+        case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+        case XGL_ERROR_DEVICE_ALREADY_CREATED:
+        case XGL_ERROR_DEVICE_LOST:
+        case XGL_ERROR_INCOMPATIBLE_DEVICE:
+        case XGL_ERROR_INCOMPATIBLE_DRIVER:
+        case XGL_ERROR_INCOMPATIBLE_QUEUE:
+        case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+        case XGL_ERROR_INITIALIZATION_FAILED:
+        case XGL_ERROR_INVALID_ALIGNMENT:
+        case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+        case XGL_ERROR_INVALID_EXTENSION:
+        case XGL_ERROR_INVALID_FLAGS:
+        case XGL_ERROR_INVALID_FORMAT:
+        case XGL_ERROR_INVALID_HANDLE:
+        case XGL_ERROR_INVALID_IMAGE:
+        case XGL_ERROR_INVALID_MEMORY_SIZE:
+        case XGL_ERROR_INVALID_OBJECT_TYPE:
+        case XGL_ERROR_INVALID_ORDINAL:
+        case XGL_ERROR_INVALID_POINTER:
+        case XGL_ERROR_INVALID_QUEUE_TYPE:
+        case XGL_ERROR_INVALID_VALUE:
+        case XGL_ERROR_MEMORY_MAP_FAILED:
+        case XGL_ERROR_MEMORY_NOT_BOUND:
+        case XGL_ERROR_MEMORY_UNMAP_FAILED:
+        case XGL_ERROR_NOT_MAPPABLE:
+        case XGL_ERROR_NOT_SHAREABLE:
+        case XGL_ERROR_OUT_OF_GPU_MEMORY:
+        case XGL_ERROR_OUT_OF_MEMORY:
+        case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+        case XGL_ERROR_UNAVAILABLE:
+        case XGL_ERROR_UNKNOWN:
+        case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+        case XGL_EVENT_RESET:
+        case XGL_EVENT_SET:
+        case XGL_NOT_READY:
+        case XGL_SUCCESS:
+        case XGL_TIMEOUT:
+        case XGL_UNSUPPORTED:
             return 1;
         default:
             return 0;
@@ -1207,13 +958,13 @@
 }
 
 
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
 {
-    switch ((XGL_QUEUE_TYPE)input_value)
+    switch ((XGL_FILL_MODE)input_value)
     {
-        case XGL_QUEUE_TYPE_COMPUTE:
-        case XGL_QUEUE_TYPE_DMA:
-        case XGL_QUEUE_TYPE_GRAPHICS:
+        case XGL_FILL_POINTS:
+        case XGL_FILL_SOLID:
+        case XGL_FILL_WIREFRAME:
             return 1;
         default:
             return 0;
@@ -1221,12 +972,12 @@
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 {
-    switch ((XGL_IMAGE_TILING)input_value)
+    switch ((XGL_TEX_FILTER)input_value)
     {
-        case XGL_LINEAR_TILING:
-        case XGL_OPTIMAL_TILING:
+        case XGL_TEX_FILTER_LINEAR:
+        case XGL_TEX_FILTER_NEAREST:
             return 1;
         default:
             return 0;
@@ -1234,14 +985,12 @@
 }
 
 
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 {
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    switch ((XGL_QUERY_TYPE)input_value)
     {
-        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
-        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+        case XGL_QUERY_OCCLUSION:
+        case XGL_QUERY_PIPELINE_STATISTICS:
             return 1;
         default:
             return 0;
@@ -1249,11 +998,20 @@
 }
 
 
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
 {
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
     {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+        case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+        case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+        case XGL_FORMAT_CONVERSION_BIT:
+        case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+        case XGL_FORMAT_IMAGE_COPY_BIT:
+        case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+        case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+        case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+        case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+        case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
             return 1;
         default:
             return 0;
@@ -1261,14 +1019,122 @@
 }
 
 
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_STATE_BIND_POINT)input_value)
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
     {
-        case XGL_STATE_BIND_COLOR_BLEND:
-        case XGL_STATE_BIND_DEPTH_STENCIL:
-        case XGL_STATE_BIND_RASTER:
-        case XGL_STATE_BIND_VIEWPORT:
+        case XGL_TIMESTAMP_BOTTOM:
+        case XGL_TIMESTAMP_TOP:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    {
+        case XGL_BORDER_COLOR_OPAQUE_BLACK:
+        case XGL_BORDER_COLOR_OPAQUE_WHITE:
+        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+{
+    switch ((XGL_LOGIC_OP)input_value)
+    {
+        case XGL_LOGIC_OP_AND:
+        case XGL_LOGIC_OP_AND_INVERTED:
+        case XGL_LOGIC_OP_AND_REVERSE:
+        case XGL_LOGIC_OP_CLEAR:
+        case XGL_LOGIC_OP_COPY:
+        case XGL_LOGIC_OP_COPY_INVERTED:
+        case XGL_LOGIC_OP_EQUIV:
+        case XGL_LOGIC_OP_INVERT:
+        case XGL_LOGIC_OP_NAND:
+        case XGL_LOGIC_OP_NOOP:
+        case XGL_LOGIC_OP_NOR:
+        case XGL_LOGIC_OP_OR:
+        case XGL_LOGIC_OP_OR_INVERTED:
+        case XGL_LOGIC_OP_OR_REVERSE:
+        case XGL_LOGIC_OP_SET:
+        case XGL_LOGIC_OP_XOR:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    {
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+{
+    switch ((XGL_IMAGE_ASPECT)input_value)
+    {
+        case XGL_IMAGE_ASPECT_COLOR:
+        case XGL_IMAGE_ASPECT_DEPTH:
+        case XGL_IMAGE_ASPECT_STENCIL:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    {
+        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+{
+    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+    {
+        case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+        case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+        case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+        case XGL_IMAGE_FORMAT_CLASS_D16:
+        case XGL_IMAGE_FORMAT_CLASS_D16S8:
+        case XGL_IMAGE_FORMAT_CLASS_D24:
+        case XGL_IMAGE_FORMAT_CLASS_D24S8:
+        case XGL_IMAGE_FORMAT_CLASS_D32:
+        case XGL_IMAGE_FORMAT_CLASS_D32S8:
+        case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+        case XGL_IMAGE_FORMAT_CLASS_S8:
             return 1;
         default:
             return 0;
@@ -1292,17 +1158,126 @@
 }
 
 
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
 {
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
     {
-        case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
-        case XGL_GPU_COMPAT_IQ_MATCH_BIT:
-        case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
-        case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
-        case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
-        case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
-        case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+        case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+    switch ((XGL_INDEX_TYPE)input_value)
+    {
+        case XGL_INDEX_16:
+        case XGL_INDEX_32:
+        case XGL_INDEX_8:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+    switch ((XGL_COMPARE_FUNC)input_value)
+    {
+        case XGL_COMPARE_ALWAYS:
+        case XGL_COMPARE_EQUAL:
+        case XGL_COMPARE_GREATER:
+        case XGL_COMPARE_GREATER_EQUAL:
+        case XGL_COMPARE_LESS:
+        case XGL_COMPARE_LESS_EQUAL:
+        case XGL_COMPARE_NEVER:
+        case XGL_COMPARE_NOT_EQUAL:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+{
+    switch ((XGL_STATE_BIND_POINT)input_value)
+    {
+        case XGL_STATE_BIND_COLOR_BLEND:
+        case XGL_STATE_BIND_DEPTH_STENCIL:
+        case XGL_STATE_BIND_RASTER:
+        case XGL_STATE_BIND_VIEWPORT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+    switch ((XGL_STENCIL_OP)input_value)
+    {
+        case XGL_STENCIL_OP_DEC_CLAMP:
+        case XGL_STENCIL_OP_DEC_WRAP:
+        case XGL_STENCIL_OP_INC_CLAMP:
+        case XGL_STENCIL_OP_INC_WRAP:
+        case XGL_STENCIL_OP_INVERT:
+        case XGL_STENCIL_OP_KEEP:
+        case XGL_STENCIL_OP_REPLACE:
+        case XGL_STENCIL_OP_ZERO:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+        case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    {
+        case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+        case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+        case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+        case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+        case XGL_IMAGE_CREATE_SPARSE_BIT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    {
+        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+        case XGL_ATTACHMENT_STORE_OP_STORE:
             return 1;
         default:
             return 0;
@@ -1335,26 +1310,51 @@
 }
 
 
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
 {
-    switch ((XGL_LOGIC_OP)input_value)
+    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
     {
-        case XGL_LOGIC_OP_AND:
-        case XGL_LOGIC_OP_AND_INVERTED:
-        case XGL_LOGIC_OP_AND_REVERSE:
-        case XGL_LOGIC_OP_CLEAR:
-        case XGL_LOGIC_OP_COPY:
-        case XGL_LOGIC_OP_COPY_INVERTED:
-        case XGL_LOGIC_OP_EQUIV:
-        case XGL_LOGIC_OP_INVERT:
-        case XGL_LOGIC_OP_NAND:
-        case XGL_LOGIC_OP_NOOP:
-        case XGL_LOGIC_OP_NOR:
-        case XGL_LOGIC_OP_OR:
-        case XGL_LOGIC_OP_OR_INVERTED:
-        case XGL_LOGIC_OP_OR_REVERSE:
-        case XGL_LOGIC_OP_SET:
-        case XGL_LOGIC_OP_XOR:
+        case XGL_IMAGE_VIEW_1D:
+        case XGL_IMAGE_VIEW_2D:
+        case XGL_IMAGE_VIEW_3D:
+        case XGL_IMAGE_VIEW_CUBE:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    {
+        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+    switch ((XGL_FACE_ORIENTATION)input_value)
+    {
+        case XGL_FRONT_FACE_CCW:
+        case XGL_FRONT_FACE_CW:
             return 1;
         default:
             return 0;
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h
index 3ce093b..2c92755 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h
@@ -6,213 +6,122 @@
 // Function Prototypes
 size_t get_struct_chain_size(const void* pStruct);
 size_t get_dynamic_struct_size(const void* pStruct);
-size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
-size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
-size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
-size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
-size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
-size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct);
-size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
-size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
-size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
-size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
-size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
-size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
-size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
-size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
-size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
-size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
-size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
-size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
 size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
-size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
 size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
-size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
-size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
-size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
-size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
-size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
-size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
-size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
-size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
-size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct);
-size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
-size_t xgl_size_xgl_rect(const XGL_RECT* pStruct);
-size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
-size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
-size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
-size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct);
-size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
-size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
-size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
-size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct);
-size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
-size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
-size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
-size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
-size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct);
-size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
-size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
-size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
-size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
-size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
-size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
-size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
+size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
 size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
-size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
+size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
+size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
+size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
+size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
+size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
+size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
+size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
+size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
+size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
+size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct);
+size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
 size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct);
+size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
+size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
+size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
+size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_rect(const XGL_RECT* pStruct);
+size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
+size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
+size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
+size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
+size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
+size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
+size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
+size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
+size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
+size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct);
+size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
+size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
+size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
+size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
+size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
+size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
+size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
+size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
+size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
+size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
+size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
+size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
+size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct);
+size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
+size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct);
+size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
+size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
+size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
+size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
+size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
 
 
-size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_FORMAT_PROPERTIES);
+        structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
+size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_IMAGE_COPY);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_SAMPLER_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_UPDATE_AS_COPY);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_CLEAR_COLOR);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_EXTENT2D);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_FRAMEBUFFER_CREATE_INFO);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->colorAttachmentCount; i++) {
-            structSize += xgl_size_xgl_color_attachment_bind_info(&pStruct->pColorAttachments[i]);
-        }
-        structSize += xgl_size_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_ALLOC_CALLBACKS);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_REQUIREMENTS);
+        structSize = sizeof(XGL_APPLICATION_INFO);
+        structSize += sizeof(char)*(1+strlen(pStruct->pAppName));
+        structSize += sizeof(char)*(1+strlen(pStruct->pEngineName));
     }
     return structSize;
 }
@@ -225,11 +134,28 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
+size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+        structSize = sizeof(XGL_UPDATE_SAMPLERS);
+        structSize += pStruct->count*sizeof(XGL_SAMPLER);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_STENCIL_OP_STATE);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO);
     }
     return structSize;
 }
@@ -248,90 +174,6 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_RESOLVE);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_FENCE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_COPY);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->attachmentCount; i++) {
-            structSize += xgl_size_xgl_pipeline_cb_attachment_state(&pStruct->pAttachments[i]);
-        }
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO);
-    }
-    return structSize;
-}
 size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
 {
     size_t structSize = 0;
@@ -340,394 +182,6 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO);
-        structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_EVENT_WAIT_INFO);
-        structSize += pStruct->eventCount*sizeof(XGL_EVENT);
-        structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->count; i++) {
-            structSize += xgl_size_xgl_descriptor_type_count(&pStruct->pTypeCount[i]);
-        }
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_ALLOC_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_OPEN_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_BARRIER);
-        structSize += pStruct->eventCount*sizeof(XGL_SET_EVENT);
-        structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_BARRIER);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_APPLICATION_INFO);
-        structSize += sizeof(char)*(1+strlen(pStruct->pAppName));
-        structSize += sizeof(char)*(1+strlen(pStruct->pEngineName));
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_MEMORY_BIND_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_SUBRESOURCE);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DRAW_INDIRECT_CMD);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_COPY);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_CHANNEL_MAPPING);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
-            structSize += xgl_size_xgl_viewport(&pStruct->pViewports[i]);
-        }
-        for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
-            structSize += xgl_size_xgl_rect(&pStruct->pScissors[i]);
-        }
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_RENDER_PASS_CREATE_INFO);
-        structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP);
-        structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->colorAttachmentCount; i++) {
-            structSize += xgl_size_xgl_clear_color(&pStruct->pColorLoadClearValues[i]);
-        }
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_VIEWPORT);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_rect(const XGL_RECT* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_RECT);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_UPDATE_SAMPLER_TEXTURES);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->count; i++) {
-            structSize += xgl_size_xgl_sampler_image_view_info(&pStruct->pSamplerImageViews[i]);
-        }
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_EVENT_CREATE_INFO);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_OFFSET2D);
-    }
-    return structSize;
-}
 size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
 {
     size_t structSize = 0;
@@ -740,19 +194,11 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
+size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_REF);
-    }
-    return structSize;
-}
-size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
-{
-    size_t structSize = 0;
-    if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO);
+        structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
     }
     return structSize;
 }
@@ -771,11 +217,42 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
+size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_GPU_COMPATIBILITY_INFO);
+        structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
+            structSize += xgl_size_xgl_viewport(&pStruct->pViewports[i]);
+        }
+        for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
+            structSize += xgl_size_xgl_rect(&pStruct->pScissors[i]);
+        }
     }
     return structSize;
 }
@@ -788,47 +265,124 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct)
+size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_OFFSET3D);
+        structSize = sizeof(XGL_MEMORY_REF);
     }
     return structSize;
 }
-size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_LAYER_CREATE_INFO);
+        structSize = sizeof(XGL_FORMAT_PROPERTIES);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_ALLOC_CALLBACKS);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO);
         uint32_t i = 0;
-        for (i = 0; i < pStruct->layerCount; i++) {
-            structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppActiveLayerNames[i]))));
+        for (i = 0; i < pStruct->attachmentCount; i++) {
+            structSize += xgl_size_xgl_pipeline_cb_attachment_state(&pStruct->pAttachments[i]);
         }
     }
     return structSize;
 }
-size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO);
+        structSize = sizeof(XGL_DRAW_INDIRECT_CMD);
     }
     return structSize;
 }
-size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO);
+        structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+        structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_FENCE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_FRAMEBUFFER_CREATE_INFO);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->colorAttachmentCount; i++) {
+            structSize += xgl_size_xgl_color_attachment_bind_info(&pStruct->pColorAttachments[i]);
+        }
+        structSize += xgl_size_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_EXTENT2D);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
     }
     return structSize;
 }
@@ -840,6 +394,70 @@
     }
     return structSize;
 }
+size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_OFFSET2D);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_CLEAR_COLOR_VALUE);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_IMAGE_CREATE_INFO);
+    }
+    return structSize;
+}
 size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
 {
     size_t structSize = 0;
@@ -852,35 +470,43 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD);
+        structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct)
+size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_EXTENT3D);
+        structSize = sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_CLEAR_COLOR_VALUE);
+        structSize = sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+size_t xgl_size_xgl_rect(const XGL_RECT* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
+        structSize = sizeof(XGL_RECT);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
     }
     return structSize;
 }
@@ -892,11 +518,327 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_STENCIL_OP_STATE);
+        structSize = sizeof(XGL_MEMORY_OPEN_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_UPDATE_AS_COPY);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_IMAGE_COPY);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_IMAGE_RESOLVE);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PIPELINE_BARRIER);
+        structSize += pStruct->eventCount*sizeof(XGL_SET_EVENT);
+        structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_UPDATE_SAMPLER_TEXTURES);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->count; i++) {
+            structSize += xgl_size_xgl_sampler_image_view_info(&pStruct->pSamplerImageViews[i]);
+        }
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->count; i++) {
+            structSize += xgl_size_xgl_descriptor_type_count(&pStruct->pTypeCount[i]);
+        }
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_VIEWPORT);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_MEMORY_REQUIREMENTS);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_MEMORY_BARRIER);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_CHANNEL_MAPPING);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_CLEAR_COLOR);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_SAMPLER_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_EVENT_WAIT_INFO);
+        structSize += pStruct->eventCount*sizeof(XGL_EVENT);
+        structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_BUFFER_IMAGE_COPY);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_EVENT_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_BUFFER_COPY);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_IMAGE_MEMORY_BIND_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
     }
     return structSize;
 }
@@ -912,60 +854,118 @@
     }
     return structSize;
 }
-size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO);
+        structSize = sizeof(XGL_OFFSET3D);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA);
+        structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
+size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
+        structSize = sizeof(XGL_EXTENT3D);
     }
     return structSize;
 }
-size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
+        structSize = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO);
+        structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView);
     }
     return structSize;
 }
-size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
+size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_UPDATE_SAMPLERS);
-        structSize += pStruct->count*sizeof(XGL_SAMPLER);
+        structSize = sizeof(XGL_IMAGE_SUBRESOURCE);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_CREATE_INFO);
+        structSize = sizeof(XGL_LAYER_CREATE_INFO);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->layerCount; i++) {
+            structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppActiveLayerNames[i]))));
+        }
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_BUFFER_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_RENDER_PASS_CREATE_INFO);
+        structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP);
+        structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->colorAttachmentCount; i++) {
+            structSize += xgl_size_xgl_clear_color(&pStruct->pColorLoadClearValues[i]);
+        }
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_GPU_COMPATIBILITY_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_MEMORY_ALLOC_INFO);
+    }
+    return structSize;
+}
+size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
+{
+    size_t structSize = 0;
+    if (pStruct) {
+        structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
     }
     return structSize;
 }
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h
index b6568c4..7cf0102 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h
@@ -115,49 +115,7 @@
 #define snprintf _snprintf
 #endif // _WIN32
 
-char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
-    return str;
-}
-char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %simageSubresource (%p)\n%s", prefix, (void*)&pStruct->imageSubresource, tmpStr);
-    tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %simageOffset (%p)\n%s", prefix, (void*)&pStruct->imageOffset, tmpStr);
-    tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %simageExtent (%p)\n%s", prefix, (void*)&pStruct->imageExtent, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sbufferOffset = %p\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (void*)(pStruct->bufferOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -177,7 +135,264 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData));
+    return str;
+}
+char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplers));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
+    return str;
+}
+char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
+    return str;
+}
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pRequestedQueues) {
+        tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spRequestedQueues (%p)\n%s", prefix, (void*)pStruct->pRequestedQueues, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+    return str;
+}
+char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pBufferViews) {
+        tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spBufferViews (%p)\n%s", prefix, (void*)pStruct->pBufferViews, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pBufferViews));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
+    return str;
+}
+char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pVertexBindingDescriptions) {
+        tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexBindingDescriptions, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    if (pStruct->pVertexAttributeDescriptions) {
+        tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[2] = (char*)malloc(len);
+        snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexAttributeDescriptions, tmpStr);
+    }
+    else
+        stp_strs[2] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbindingCount = %u\n%spVertexBindingDescriptions = %p\n%sattributeCount = %u\n%spVertexAttributeDescriptions = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->bindingCount), prefix, (void*)(pStruct->pVertexBindingDescriptions), prefix, (pStruct->attributeCount), prefix, (void*)(pStruct->pVertexAttributeDescriptions));
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdepthBias = %f\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n%spointSize = %f\n%spointFadeThreshold = %f\n%slineWidth = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (pStruct->pointSize), prefix, (pStruct->pointFadeThreshold), prefix, (pStruct->lineWidth));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -196,45 +411,6 @@
     snprintf(str, len, "%soffset = %p\n%ssize = %p\n%srowPitch = %p\n%sdepthPitch = %p\n", prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->rowPitch), prefix, (void*)(pStruct->depthPitch));
     return str;
 }
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
-    return str;
-}
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
 char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
 {
     char* str;
@@ -244,7 +420,53 @@
     snprintf(str, len, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
     return str;
 }
-char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pViewports) {
+        tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spViewports (%p)\n%s", prefix, (void*)pStruct->pViewports, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    if (pStruct->pScissors) {
+        tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[2] = (char*)malloc(len);
+        snprintf(stp_strs[2], len, " %spScissors (%p)\n%s", prefix, (void*)pStruct->pScissors, tmpStr);
+    }
+    else
+        stp_strs[2] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sviewportAndScissorCount = %u\n%spViewports = %p\n%spScissors = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->viewportAndScissorCount), prefix, (void*)(pStruct->pViewports), prefix, (void*)(pStruct->pScissors));
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -264,7 +486,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sdescriptorSet = %p\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scodeSize = %p\n%spCode = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -274,7 +496,176 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%smem = %p\n%sflags = %u\n", prefix, (void*)(pStruct->mem), prefix, (pStruct->flags));
+    return str;
+}
+char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
+    return str;
+}
+char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
+    return str;
+}
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%spUserData = %p\n%spfnAlloc = %p\n%spfnFree = %p\n", prefix, (pStruct->pUserData), prefix, (void*)(pStruct->pfnAlloc), prefix, (void*)(pStruct->pfnFree));
+    return str;
+}
+char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pAttachments) {
+        tmpStr = xgl_print_xgl_pipeline_cb_attachment_state(pStruct->pAttachments, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spAttachments (%p)\n%s", prefix, (void*)pStruct->pAttachments, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%salphaToCoverageEnable = %s\n%slogicOpEnable = %s\n%slogicOp = %s\n%sattachmentCount = %u\n%spAttachments = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->logicOpEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (pStruct->attachmentCount), prefix, (void*)(pStruct->pAttachments));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+    return str;
+}
+char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
+    return str;
+}
+char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
+    return str;
+}
+char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -283,13 +674,18 @@
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
     char* stp_strs[1];
-    tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %scolor (%p)\n%s", prefix, (void*)&pStruct->color, tmpStr);
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%scolor = %p\n%suseRawValue = %s\n", prefix, (void*)&(pStruct->color), prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -299,15 +695,6 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
-    return str;
-}
 char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -354,43 +741,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%spUserData = %p\n%spfnAlloc = %p\n%spfnFree = %p\n", prefix, (pStruct->pUserData), prefix, (void*)(pStruct->pfnAlloc), prefix, (void*)(pStruct->pfnFree));
+    snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
     return str;
 }
-char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssize = %p\n%salignment = %p\n%sgranularity = %p\n%smemProps = %u\n%smemType = %s\n", prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->alignment), prefix, (void*)(pStruct->granularity), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
-    return str;
-}
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData));
-    return str;
-}
-char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = %p\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, (void*)(pStruct->maxInlineMemoryUpdateSize), prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
-    return str;
-}
-char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -408,59 +768,14 @@
     }
     else
         stp_strs[0] = "";
-    if (pStruct->pRequestedQueues) {
-        tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spRequestedQueues (%p)\n%s", prefix, (void*)pStruct->pRequestedQueues, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[5];
-    tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr);
-    tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
+    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
     len = 256+strlen(tmpStr);
     stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %ssrcOffset (%p)\n%s", prefix, (void*)&pStruct->srcOffset, tmpStr);
-    tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %sdestSubresource (%p)\n%s", prefix, (void*)&pStruct->destSubresource, tmpStr);
-    tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[3] = (char*)malloc(len);
-    snprintf(stp_strs[3], len, " %sdestOffset (%p)\n%s", prefix, (void*)&pStruct->destOffset, tmpStr);
-    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[4] = (char*)malloc(len);
-    snprintf(stp_strs[4], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+    snprintf(stp_strs[1], len, " %scs (%p)\n%s", prefix, (void*)&pStruct->cs, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
-    for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n%slastSetLayout = %p\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout), prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
             free(stp_strs[stp_index]);
@@ -469,149 +784,55 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdepthBias = %f\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n%spointSize = %f\n%spointFadeThreshold = %f\n%slineWidth = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (pStruct->pointSize), prefix, (pStruct->pointFadeThreshold), prefix, (pStruct->lineWidth));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssrcOffset = %p\n%sdestOffset = %p\n%scopySize = %p\n", prefix, (void*)(pStruct->srcOffset), prefix, (void*)(pStruct->destOffset), prefix, (void*)(pStruct->copySize));
+    snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
     return str;
 }
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
     return str;
 }
-char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbuffer = %p\n%sviewType = %s\n%sstride = %p\n%sformat = %s\n%schannels = %p\n%soffset = %p\n%srange = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->buffer), prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, (void*)(pStruct->stride), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->range));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -631,7 +852,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -641,113 +862,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pAttachments) {
-        tmpStr = xgl_print_xgl_pipeline_cb_attachment_state(pStruct->pAttachments, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spAttachments (%p)\n%s", prefix, (void*)pStruct->pAttachments, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%salphaToCoverageEnable = %s\n%slogicOpEnable = %s\n%slogicOp = %s\n%sattachmentCount = %u\n%spAttachments = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->logicOpEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (pStruct->attachmentCount), prefix, (void*)(pStruct->pAttachments));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->blendConst));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+    snprintf(str, len, "%sfloatColor = %p\n%srawColor = %p\n", prefix, (void*)(pStruct->floatColor), prefix, (void*)(pStruct->rawColor));
     return str;
 }
-char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pImageView) {
-        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spImageView (%p)\n%s", prefix, (void*)pStruct->pImageView, tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%spSampler = %p\n%spImageView = %p\n", prefix, (void*)(pStruct->pSampler), prefix, (void*)(pStruct->pImageView));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -767,7 +891,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix, (void*)(pStruct->immutableSampler));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = %p\n%soffset = %p\n%ssize = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, (void*)(pStruct->buffer), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -777,198 +901,6 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pTypeCount) {
-        tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scount = %u\n%spTypeCount = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->count), prefix, (void*)(pStruct->pTypeCount));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sallocationSize = %p\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->allocationSize), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n%slastSetLayout = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
 char* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -999,165 +931,6 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
-    return str;
-}
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
 char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1188,7 +961,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1206,13 +979,13 @@
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+    tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
     len = 256+strlen(tmpStr);
     stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+    snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
     len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %s\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
     for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1222,7 +995,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1230,23 +1003,28 @@
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr);
-    tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
-    tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pImageViews) {
+        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spImageViews (%p)\n%s", prefix, (void*)pStruct->pImageViews, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssubresource = %p\n%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->subresource), prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pImageViews));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
             free(stp_strs[stp_index]);
@@ -1255,22 +1033,34 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
-    len = sizeof(char)*1024;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
-    return str;
-}
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
     return str;
 }
 char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
@@ -1311,7 +1101,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1331,7 +1121,135 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n%slastSetLayout = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
+    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderPass = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->renderPass));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+    return str;
+}
+char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sdescriptorSet = %p\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1382,7 +1300,57 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[5];
+    tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr);
+    tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %ssrcOffset (%p)\n%s", prefix, (void*)&pStruct->srcOffset, tmpStr);
+    tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %sdestSubresource (%p)\n%s", prefix, (void*)&pStruct->destSubresource, tmpStr);
+    tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[3] = (char*)malloc(len);
+    snprintf(stp_strs[3], len, " %sdestOffset (%p)\n%s", prefix, (void*)&pStruct->destOffset, tmpStr);
+    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[4] = (char*)malloc(len);
+    snprintf(stp_strs[4], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
+    for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    return str;
+}
+char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1402,7 +1370,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1446,352 +1414,6 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %scs (%p)\n%s", prefix, (void*)&pStruct->cs, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n%slastSetLayout = %p\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout), prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
-    return str;
-}
-char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
-    return str;
-}
-char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pViewports) {
-        tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spViewports (%p)\n%s", prefix, (void*)pStruct->pViewports, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    if (pStruct->pScissors) {
-        tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[2] = (char*)malloc(len);
-        snprintf(stp_strs[2], len, " %spScissors (%p)\n%s", prefix, (void*)pStruct->pScissors, tmpStr);
-    }
-    else
-        stp_strs[2] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sviewportAndScissorCount = %u\n%spViewports = %p\n%spScissors = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->viewportAndScissorCount), prefix, (void*)(pStruct->pViewports), prefix, (void*)(pStruct->pScissors));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
-    return str;
-}
-char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %srenderArea (%p)\n%s", prefix, (void*)&pStruct->renderArea, tmpStr);
-    if (pStruct->pColorLoadClearValues) {
-        tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[2] = (char*)malloc(len);
-        snprintf(stp_strs[2], len, " %spColorLoadClearValues (%p)\n%s", prefix, (void*)pStruct->pColorLoadClearValues, tmpStr);
-    }
-    else
-        stp_strs[2] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderArea = %p\n%sframebuffer = %p\n%scolorAttachmentCount = %u\n%spColorLoadOps = %p\n%spColorStoreOps = %p\n%spColorLoadClearValues = %p\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->renderArea), prefix, (void*)(pStruct->framebuffer), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorLoadOps), prefix, (void*)(pStruct->pColorStoreOps), prefix, (void*)(pStruct->pColorLoadClearValues), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
-    return str;
-}
-char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssize = %p\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->size), prefix, (pStruct->usage), prefix, (pStruct->flags));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderPass = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->renderPass));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
-    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = %p\n%soffset = %p\n%ssize = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, (void*)(pStruct->buffer), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
 char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1830,13 +1452,73 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+    snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
+    return str;
+}
+char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
     return str;
 }
 char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
@@ -1877,6 +1559,135 @@
     free(extra_indent);
     return str;
 }
+char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+    return str;
+}
+char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+    return str;
+}
+char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pTypeCount) {
+        tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scount = %u\n%spTypeCount = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->count), prefix, (void*)(pStruct->pTypeCount));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
+    return str;
+}
+char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource), prefix, (pStruct->flags));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
 char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1907,6 +1718,314 @@
     free(extra_indent);
     return str;
 }
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    return str;
+}
+char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssize = %p\n%salignment = %p\n%sgranularity = %p\n%smemProps = %u\n%smemType = %s\n", prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->alignment), prefix, (void*)(pStruct->granularity), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
+    return str;
+}
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
+    return str;
+}
+char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+    return str;
+}
+char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %scolor (%p)\n%s", prefix, (void*)&pStruct->color, tmpStr);
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%scolor = %p\n%suseRawValue = %s\n", prefix, (void*)&(pStruct->color), prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->blendConst));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbuffer = %p\n%sviewType = %s\n%sstride = %p\n%sformat = %s\n%schannels = %p\n%soffset = %p\n%srange = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->buffer), prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, (void*)(pStruct->stride), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->range));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %simageSubresource (%p)\n%s", prefix, (void*)&pStruct->imageSubresource, tmpStr);
+    tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %simageOffset (%p)\n%s", prefix, (void*)&pStruct->imageOffset, tmpStr);
+    tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %simageExtent (%p)\n%s", prefix, (void*)&pStruct->imageExtent, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sbufferOffset = %p\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (void*)(pStruct->bufferOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent));
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
 char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1937,16 +2056,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+    snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = %p\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, (void*)(pStruct->maxInlineMemoryUpdateSize), prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
     return str;
 }
-char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1954,7 +2073,7 @@
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
+    char* stp_strs[1];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1964,18 +2083,10 @@
     }
     else
         stp_strs[0] = "";
-    if (pStruct->pBufferViews) {
-        tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spBufferViews (%p)\n%s", prefix, (void*)pStruct->pBufferViews, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pBufferViews));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
             free(stp_strs[stp_index]);
@@ -1984,13 +2095,123 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%smem = %p\n%sflags = %u\n", prefix, (void*)(pStruct->mem), prefix, (pStruct->flags));
+    snprintf(str, len, "%ssrcOffset = %p\n%sdestOffset = %p\n%scopySize = %p\n", prefix, (void*)(pStruct->srcOffset), prefix, (void*)(pStruct->destOffset), prefix, (void*)(pStruct->copySize));
+    return str;
+}
+char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr);
+    tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
+    tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssubresource = %p\n%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->subresource), prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+    return str;
+}
+char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pLinkConstBufferInfo) {
+        tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (%p)\n%s", prefix, (void*)pStruct->pLinkConstBufferInfo, tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sstage = %s\n%sshader = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
     return str;
 }
 char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
@@ -2023,62 +2244,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pVertexBindingDescriptions) {
-        tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexBindingDescriptions, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    if (pStruct->pVertexAttributeDescriptions) {
-        tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[2] = (char*)malloc(len);
-        snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexAttributeDescriptions, tmpStr);
-    }
-    else
-        stp_strs[2] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbindingCount = %u\n%spVertexBindingDescriptions = %p\n%sattributeCount = %u\n%spVertexAttributeDescriptions = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->bindingCount), prefix, (void*)(pStruct->pVertexBindingDescriptions), prefix, (pStruct->attributeCount), prefix, (void*)(pStruct->pVertexAttributeDescriptions));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+    snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
     return str;
 }
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2087,18 +2262,17 @@
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
     char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
+    if (pStruct->pImageView) {
+        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
         stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
+        snprintf(stp_strs[0], len, " %spImageView (%p)\n%s", prefix, (void*)pStruct->pImageView, tmpStr);
     }
     else
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scodeSize = %p\n%spCode = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags));
+    snprintf(str, len, "%spSampler = %p\n%spImageView = %p\n", prefix, (void*)(pStruct->pSampler), prefix, (void*)(pStruct->pImageView));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2108,13 +2282,13 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+    snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
     return str;
 }
 char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
@@ -2147,7 +2321,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2155,7 +2329,7 @@
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
+    char* stp_strs[1];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -2165,79 +2339,82 @@
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssize = %p\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->size), prefix, (pStruct->usage), prefix, (pStruct->flags));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
     len = 256+strlen(tmpStr);
     stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource), prefix, (pStruct->flags));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
-    return str;
-}
-char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
-    return str;
-}
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
-    return str;
-}
-char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pImageViews) {
-        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+    snprintf(stp_strs[1], len, " %srenderArea (%p)\n%s", prefix, (void*)&pStruct->renderArea, tmpStr);
+    if (pStruct->pColorLoadClearValues) {
+        tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
         len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spImageViews (%p)\n%s", prefix, (void*)pStruct->pImageViews, tmpStr);
+        stp_strs[2] = (char*)malloc(len);
+        snprintf(stp_strs[2], len, " %spColorLoadClearValues (%p)\n%s", prefix, (void*)pStruct->pColorLoadClearValues, tmpStr);
     }
     else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+        stp_strs[2] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pImageViews));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderArea = %p\n%sframebuffer = %p\n%scolorAttachmentCount = %u\n%spColorLoadOps = %p\n%spColorStoreOps = %p\n%spColorLoadClearValues = %p\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->renderArea), prefix, (void*)(pStruct->framebuffer), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorLoadOps), prefix, (void*)(pStruct->pColorStoreOps), prefix, (void*)(pStruct->pColorLoadClearValues), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
             free(stp_strs[stp_index]);
@@ -2246,34 +2423,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
-    return str;
-}
-char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
-    return str;
-}
-char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sfloatColor = %p\n%srawColor = %p\n", prefix, (void*)(pStruct->floatColor), prefix, (void*)(pStruct->rawColor));
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2293,7 +2443,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix, (void*)(pStruct->immutableSampler));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2303,54 +2453,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+    snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
     return str;
 }
-char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
-    return str;
-}
-char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pLinkConstBufferInfo) {
-        tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (%p)\n%s", prefix, (void*)pStruct->pLinkConstBufferInfo, tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sstage = %s\n%sshader = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2370,7 +2482,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sallocationSize = %p\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->allocationSize), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2380,125 +2492,13 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
-    return str;
-}
-char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
-    return str;
-}
-char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
-    return str;
-}
-char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplers));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %s\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
+    snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
     return str;
 }
 char* dynamic_display(const void* pStruct, const char* prefix)
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h
index 435ef71..b792ea2 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h
@@ -115,49 +115,7 @@
 #define snprintf _snprintf
 #endif // _WIN32
 
-char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
-    return str;
-}
-char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %simageSubresource (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %simageOffset (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %simageExtent (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sbufferOffset = addr\n%simageSubresource = addr\n%simageOffset = addr\n%simageExtent = addr\n", prefix, prefix, prefix, prefix);
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -177,7 +135,264 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soriginalMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spAppName = addr\n%sappVersion = %u\n%spEngineName = addr\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->appVersion), prefix, prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix);
+    return str;
+}
+char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->index), prefix, (pStruct->count), prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
+    return str;
+}
+char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%soriginalImage = addr\n", prefix);
+    return str;
+}
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pRequestedQueues) {
+        tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spRequestedQueues (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueRecordCount = %u\n%spRequestedQueues = addr\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->queueRecordCount), prefix, prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+    return str;
+}
+char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pBufferViews) {
+        tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spBufferViews (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
+    return str;
+}
+char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pVertexBindingDescriptions) {
+        tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    if (pStruct->pVertexAttributeDescriptions) {
+        tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[2] = (char*)malloc(len);
+        snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[2] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbindingCount = %u\n%spVertexBindingDescriptions = addr\n%sattributeCount = %u\n%spVertexAttributeDescriptions = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->bindingCount), prefix, prefix, (pStruct->attributeCount), prefix);
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdepthBias = %f\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n%spointSize = %f\n%spointFadeThreshold = %f\n%slineWidth = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (pStruct->pointSize), prefix, (pStruct->pointFadeThreshold), prefix, (pStruct->lineWidth));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -196,45 +411,6 @@
     snprintf(str, len, "%soffset = addr\n%ssize = addr\n%srowPitch = addr\n%sdepthPitch = addr\n", prefix, prefix, prefix, prefix);
     return str;
 }
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
-    return str;
-}
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
 char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
 {
     char* str;
@@ -244,7 +420,53 @@
     snprintf(str, len, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
     return str;
 }
-char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pViewports) {
+        tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spViewports (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    if (pStruct->pScissors) {
+        tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[2] = (char*)malloc(len);
+        snprintf(stp_strs[2], len, " %spScissors (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[2] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sviewportAndScissorCount = %u\n%spViewports = addr\n%spScissors = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->viewportAndScissorCount), prefix, prefix);
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -264,7 +486,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sdescriptorSet = addr\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scodeSize = addr\n%spCode = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->flags));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -274,7 +496,176 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%smem = addr\n%sflags = %u\n", prefix, prefix, (pStruct->flags));
+    return str;
+}
+char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
+    return str;
+}
+char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
+    return str;
+}
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%spUserData = addr\n%spfnAlloc = addr\n%spfnFree = addr\n", prefix, prefix, prefix);
+    return str;
+}
+char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pAttachments) {
+        tmpStr = xgl_print_xgl_pipeline_cb_attachment_state(pStruct->pAttachments, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spAttachments (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%salphaToCoverageEnable = %s\n%slogicOpEnable = %s\n%slogicOp = %s\n%sattachmentCount = %u\n%spAttachments = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->logicOpEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (pStruct->attachmentCount), prefix);
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+    return str;
+}
+char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix);
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
+    return str;
+}
+char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
+    return str;
+}
+char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %sshader (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -283,13 +674,18 @@
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
     char* stp_strs[1];
-    tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %scolor (addr)\n%s", prefix, tmpStr);
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%scolor = addr\n%suseRawValue = %s\n", prefix, prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -299,15 +695,6 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
-    return str;
-}
 char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -354,43 +741,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%spUserData = addr\n%spfnAlloc = addr\n%spfnFree = addr\n", prefix, prefix, prefix);
+    snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
     return str;
 }
-char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssize = addr\n%salignment = addr\n%sgranularity = addr\n%smemProps = %u\n%smemType = %s\n", prefix, prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
-    return str;
-}
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix);
-    return str;
-}
-char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = addr\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
-    return str;
-}
-char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -408,59 +768,14 @@
     }
     else
         stp_strs[0] = "";
-    if (pStruct->pRequestedQueues) {
-        tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spRequestedQueues (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueRecordCount = %u\n%spRequestedQueues = addr\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->queueRecordCount), prefix, prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[5];
-    tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %ssrcSubresource (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
+    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
     len = 256+strlen(tmpStr);
     stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %ssrcOffset (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %sdestSubresource (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[3] = (char*)malloc(len);
-    snprintf(stp_strs[3], len, " %sdestOffset (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[4] = (char*)malloc(len);
-    snprintf(stp_strs[4], len, " %sextent (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+    snprintf(stp_strs[1], len, " %scs (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssrcSubresource = addr\n%ssrcOffset = addr\n%sdestSubresource = addr\n%sdestOffset = addr\n%sextent = addr\n", prefix, prefix, prefix, prefix, prefix);
-    for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scs = addr\n%sflags = %u\n%slastSetLayout = addr\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->flags), prefix, prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
             free(stp_strs[stp_index]);
@@ -469,149 +784,55 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdepthBias = %f\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n%spointSize = %f\n%spointFadeThreshold = %f\n%slineWidth = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (pStruct->pointSize), prefix, (pStruct->pointFadeThreshold), prefix, (pStruct->lineWidth));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssrcOffset = addr\n%sdestOffset = addr\n%scopySize = addr\n", prefix, prefix, prefix);
+    snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
     return str;
 }
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
     return str;
 }
-char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbuffer = addr\n%sviewType = %s\n%sstride = addr\n%sformat = %s\n%schannels = addr\n%soffset = addr\n%srange = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix);
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -631,7 +852,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedSemaphore = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->initialCount), prefix, (pStruct->flags));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -641,113 +862,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pAttachments) {
-        tmpStr = xgl_print_xgl_pipeline_cb_attachment_state(pStruct->pAttachments, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spAttachments (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%salphaToCoverageEnable = %s\n%slogicOpEnable = %s\n%slogicOp = %s\n%sattachmentCount = %u\n%spAttachments = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->logicOpEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (pStruct->attachmentCount), prefix);
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sblendConst = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+    snprintf(str, len, "%sfloatColor = addr\n%srawColor = addr\n", prefix, prefix);
     return str;
 }
-char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pImageView) {
-        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spImageView (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%spSampler = addr\n%spImageView = addr\n", prefix, prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -767,7 +891,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = addr\n%soffset = addr\n%ssize = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, prefix, prefix);
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -777,198 +901,6 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pTypeCount) {
-        tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spTypeCount (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scount = %u\n%spTypeCount = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->count), prefix);
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sallocationSize = addr\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n%slastSetLayout = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags), prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %sshader (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
 char* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -999,165 +931,6 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
-    return str;
-}
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spAppName = addr\n%sappVersion = %u\n%spEngineName = addr\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->appVersion), prefix, prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
 char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1188,7 +961,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1206,13 +979,13 @@
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+    tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
     len = 256+strlen(tmpStr);
     stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+    snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
     len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simageType = %s\n%sformat = %s\n%sextent = addr\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
     for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1222,7 +995,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1230,23 +1003,28 @@
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %ssubresource (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %soffset (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %sextent (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pImageViews) {
+        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spImageViews (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssubresource = addr\n%soffset = addr\n%sextent = addr\n", prefix, prefix, prefix);
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
             free(stp_strs[stp_index]);
@@ -1255,22 +1033,34 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
-    len = sizeof(char)*1024;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
-    return str;
-}
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
     return str;
 }
 char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
@@ -1311,7 +1101,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1331,7 +1121,135 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n%slastSetLayout = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags), prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %soffset (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%soffset = addr\n%sextent = addr\n", prefix, prefix);
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderPass = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+    return str;
+}
+char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sdescriptorSet = addr\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1382,7 +1300,57 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[5];
+    tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %ssrcSubresource (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %ssrcOffset (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %sdestSubresource (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[3] = (char*)malloc(len);
+    snprintf(stp_strs[3], len, " %sdestOffset (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[4] = (char*)malloc(len);
+    snprintf(stp_strs[4], len, " %sextent (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssrcSubresource = addr\n%ssrcOffset = addr\n%sdestSubresource = addr\n%sdestOffset = addr\n%sextent = addr\n", prefix, prefix, prefix, prefix, prefix);
+    for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    return str;
+}
+char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1402,7 +1370,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1446,352 +1414,6 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %scs (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scs = addr\n%sflags = %u\n%slastSetLayout = addr\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->flags), prefix, prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
-    return str;
-}
-char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%soriginalImage = addr\n", prefix);
-    return str;
-}
-char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pViewports) {
-        tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spViewports (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    if (pStruct->pScissors) {
-        tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[2] = (char*)malloc(len);
-        snprintf(stp_strs[2], len, " %spScissors (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[2] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sviewportAndScissorCount = %u\n%spViewports = addr\n%spScissors = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->viewportAndScissorCount), prefix, prefix);
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
-    return str;
-}
-char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %srenderArea (addr)\n%s", prefix, tmpStr);
-    if (pStruct->pColorLoadClearValues) {
-        tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[2] = (char*)malloc(len);
-        snprintf(stp_strs[2], len, " %spColorLoadClearValues (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[2] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderArea = addr\n%sframebuffer = addr\n%scolorAttachmentCount = %u\n%spColorLoadOps = addr\n%spColorStoreOps = addr\n%spColorLoadClearValues = addr\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
-    return str;
-}
-char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssize = addr\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->usage), prefix, (pStruct->flags));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderPass = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[0] = (char*)malloc(len);
-    snprintf(stp_strs[0], len, " %soffset (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%soffset = addr\n%sextent = addr\n", prefix, prefix);
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = addr\n%soffset = addr\n%ssize = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, prefix, prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
 char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1830,13 +1452,73 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+    snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
+    return str;
+}
+char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
     return str;
 }
 char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
@@ -1877,6 +1559,135 @@
     free(extra_indent);
     return str;
 }
+char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soriginalMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+    return str;
+}
+char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+    return str;
+}
+char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    if (pStruct->pTypeCount) {
+        tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spTypeCount (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scount = %u\n%spTypeCount = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->count), prefix);
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
+    return str;
+}
+char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix, prefix, (pStruct->flags));
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
 char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1907,6 +1718,314 @@
     free(extra_indent);
     return str;
 }
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    return str;
+}
+char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssize = addr\n%salignment = addr\n%sgranularity = addr\n%smemProps = %u\n%smemType = %s\n", prefix, prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
+    return str;
+}
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedSemaphore = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
+    return str;
+}
+char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+    return str;
+}
+char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %scolor (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%scolor = addr\n%suseRawValue = %s\n", prefix, prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sblendConst = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[2];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbuffer = addr\n%sviewType = %s\n%sstride = addr\n%sformat = %s\n%schannels = addr\n%soffset = addr\n%srange = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix);
+    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %simageSubresource (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %simageOffset (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %simageExtent (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sbufferOffset = addr\n%simageSubresource = addr\n%simageOffset = addr\n%simageExtent = addr\n", prefix, prefix, prefix, prefix);
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
 char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1937,16 +2056,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+    snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = addr\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
     return str;
 }
-char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1954,7 +2073,7 @@
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
+    char* stp_strs[1];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1964,18 +2083,10 @@
     }
     else
         stp_strs[0] = "";
-    if (pStruct->pBufferViews) {
-        tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spBufferViews (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
             free(stp_strs[stp_index]);
@@ -1984,13 +2095,123 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%smem = addr\n%sflags = %u\n", prefix, prefix, (pStruct->flags));
+    snprintf(str, len, "%ssrcOffset = addr\n%sdestOffset = addr\n%scopySize = addr\n", prefix, prefix, prefix);
+    return str;
+}
+char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[0] = (char*)malloc(len);
+    snprintf(stp_strs[0], len, " %ssubresource (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %soffset (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %sextent (addr)\n%s", prefix, tmpStr);
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssubresource = addr\n%soffset = addr\n%sextent = addr\n", prefix, prefix, prefix);
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+    return str;
+}
+char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pLinkConstBufferInfo) {
+        tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sstage = %s\n%sshader = addr\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = addr\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, prefix, (pStruct->linkConstBufferCount), prefix);
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
     return str;
 }
 char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
@@ -2023,62 +2244,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pVertexBindingDescriptions) {
-        tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[1] = "";
-    if (pStruct->pVertexAttributeDescriptions) {
-        tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[2] = (char*)malloc(len);
-        snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[2] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbindingCount = %u\n%spVertexBindingDescriptions = addr\n%sattributeCount = %u\n%spVertexAttributeDescriptions = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->bindingCount), prefix, prefix, (pStruct->attributeCount), prefix);
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+    snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
     return str;
 }
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2087,18 +2262,17 @@
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
     char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
+    if (pStruct->pImageView) {
+        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
         stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
+        snprintf(stp_strs[0], len, " %spImageView (addr)\n%s", prefix, tmpStr);
     }
     else
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scodeSize = addr\n%spCode = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->flags));
+    snprintf(str, len, "%spSampler = addr\n%spImageView = addr\n", prefix, prefix);
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2108,13 +2282,13 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+    snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
     return str;
 }
 char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
@@ -2147,7 +2321,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2155,7 +2329,7 @@
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
+    char* stp_strs[1];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -2165,79 +2339,82 @@
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[1];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    str = (char*)malloc(len);
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssize = addr\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->usage), prefix, (pStruct->flags));
+    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+        if (0 < strlen(stp_strs[stp_index])) {
+            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+            free(stp_strs[stp_index]);
+        }
+    }
+    free(extra_indent);
+    return str;
+}
+char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    char* tmpStr;
+    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+    strcpy(extra_indent, "  ");
+    strncat(extra_indent, prefix, strlen(prefix));
+    char* stp_strs[3];
+    if (pStruct->pNext) {
+        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+        len = 256+strlen(tmpStr);
+        stp_strs[0] = (char*)malloc(len);
+        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+        free(tmpStr);
+    }
+    else
+        stp_strs[0] = "";
+    tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
     len = 256+strlen(tmpStr);
     stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix, prefix, (pStruct->flags));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
-    return str;
-}
-char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
-    return str;
-}
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
-    return str;
-}
-char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    if (pStruct->pImageViews) {
-        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+    snprintf(stp_strs[1], len, " %srenderArea (addr)\n%s", prefix, tmpStr);
+    if (pStruct->pColorLoadClearValues) {
+        tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
         len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spImageViews (addr)\n%s", prefix, tmpStr);
+        stp_strs[2] = (char*)malloc(len);
+        snprintf(stp_strs[2], len, " %spColorLoadClearValues (addr)\n%s", prefix, tmpStr);
     }
     else
-        stp_strs[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+        stp_strs[2] = "";
+    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderArea = addr\n%sframebuffer = addr\n%scolorAttachmentCount = %u\n%spColorLoadOps = addr\n%spColorStoreOps = addr\n%spColorLoadClearValues = addr\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
+    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
             free(stp_strs[stp_index]);
@@ -2246,34 +2423,7 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
-    return str;
-}
-char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
-    return str;
-}
-char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sfloatColor = addr\n%srawColor = addr\n", prefix, prefix);
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2293,7 +2443,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix);
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2303,54 +2453,16 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+    snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
     return str;
 }
-char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
-    return str;
-}
-char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pLinkConstBufferInfo) {
-        tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (addr)\n%s", prefix, tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sstage = %s\n%sshader = addr\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = addr\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, prefix, (pStruct->linkConstBufferCount), prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2370,7 +2482,7 @@
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->initialCount), prefix, (pStruct->flags));
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sallocationSize = addr\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
     for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
         if (0 < strlen(stp_strs[stp_index])) {
             strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2380,125 +2492,13 @@
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
     len = sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
-    return str;
-}
-char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
-    return str;
-}
-char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
-    return str;
-}
-char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->index), prefix, (pStruct->count), prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simageType = %s\n%sformat = %s\n%sextent = addr\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
-    return str;
-}
-char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    char* tmpStr;
-    char* extra_indent = (char*)malloc(strlen(prefix) + 3);
-    strcpy(extra_indent, "  ");
-    strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
-    if (pStruct->pNext) {
-        tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
-        len = 256+strlen(tmpStr);
-        stp_strs[0] = (char*)malloc(len);
-        snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
-    }
-    else
-        stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
-    str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
-        if (0 < strlen(stp_strs[stp_index])) {
-            strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
-            free(stp_strs[stp_index]);
-        }
-    }
-    free(extra_indent);
+    snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
     return str;
 }
 char* dynamic_display(const void* pStruct, const char* prefix)
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h
index f72db36..e50bd3d 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h
@@ -8,122 +8,188 @@
 #include "xgl_enum_validate_helper.h"
 
 // Function Prototypes
-uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
-uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
-uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
-uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct);
-uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
-uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
-uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
-uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
-uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
-uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
-uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
-uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
 uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
-uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
 uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
-uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
-uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
-uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
-uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
-uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct);
-uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
-uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct);
-uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
-uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
-uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct);
-uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
-uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
-uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
-uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct);
-uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
-uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
-uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
-uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct);
-uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
-uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
-uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
-uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
-uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
-uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
+uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
 uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
-uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
+uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
+uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
+uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
+uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
+uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
+uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
+uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
+uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
+uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct);
+uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
 uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct);
+uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
+uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
+uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct);
+uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
+uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
+uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
+uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
+uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
+uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
+uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
+uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct);
+uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
+uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
+uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
+uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
+uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
+uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
+uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct);
+uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
+uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct);
+uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
+uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
 
 
-uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
 {
-    return 1;
-}
-uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
-{
-    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->imageSubresource))
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->imageOffset))
-        return 0;
-    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->imageExtent))
+    if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+{
+    if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp))
+        return 0;
+    if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp))
+        return 0;
+    if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp))
+        return 0;
+    if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues))
+        return 0;
+    if (!validate_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+        return 0;
+    if (pStruct->pBufferViews && !xgl_validate_xgl_buffer_view_attach_info((const XGL_BUFFER_VIEW_ATTACH_INFO*)pStruct->pBufferViews))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
+{
+    if (!validate_XGL_FORMAT(pStruct->format))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (pStruct->pVertexBindingDescriptions && !xgl_validate_xgl_vertex_input_binding_description((const XGL_VERTEX_INPUT_BINDING_DESCRIPTION*)pStruct->pVertexBindingDescriptions))
+        return 0;
+    if (pStruct->pVertexAttributeDescriptions && !xgl_validate_xgl_vertex_input_attribute_description((const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*)pStruct->pVertexAttributeDescriptions))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
@@ -133,10 +199,472 @@
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
 {
     return 1;
 }
+uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (pStruct->pViewports && !xgl_validate_xgl_viewport((const XGL_VIEWPORT*)pStruct->pViewports))
+        return 0;
+    if (pStruct->pScissors && !xgl_validate_xgl_rect((const XGL_RECT*)pStruct->pScissors))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_LOGIC_OP(pStruct->logicOp))
+        return 0;
+    if (pStruct->pAttachments && !xgl_validate_xgl_pipeline_cb_attachment_state((const XGL_PIPELINE_CB_ATTACHMENT_STATE*)pStruct->pAttachments))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_FORMAT(pStruct->format))
+        return 0;
+    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
+{
+    if (!validate_XGL_FORMAT(pStruct->format))
+        return 0;
+    if (!validate_XGL_BLEND(pStruct->srcBlendColor))
+        return 0;
+    if (!validate_XGL_BLEND(pStruct->destBlendColor))
+        return 0;
+    if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor))
+        return 0;
+    if (!validate_XGL_BLEND(pStruct->srcBlendAlpha))
+        return 0;
+    if (!validate_XGL_BLEND(pStruct->destBlendAlpha))
+        return 0;
+    if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+{
+    if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->shader))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments))
+        return 0;
+    if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
+{
+    if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin))
+        return 0;
+    if (!validate_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex))
+        return 0;
+    if (!validate_XGL_FILL_MODE(pStruct->fillMode))
+        return 0;
+    if (!validate_XGL_CULL_MODE(pStruct->cullMode))
+        return 0;
+    if (!validate_XGL_FACE_ORIENTATION(pStruct->frontFace))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_IMAGE_TYPE(pStruct->imageType))
+        return 0;
+    if (!validate_XGL_FORMAT(pStruct->format))
+        return 0;
+    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+        return 0;
+    if (!validate_XGL_IMAGE_TILING(pStruct->tiling))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+        return 0;
+    if (pStruct->pImageViews && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageViews))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_IMAGE_VIEW_TYPE(pStruct->viewType))
+        return 0;
+    if (!validate_XGL_FORMAT(pStruct->format))
+        return 0;
+    if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
+        return 0;
+    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct)
+{
+    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset))
+        return 0;
+    if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
+{
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
+        return 0;
+    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->srcOffset))
+        return 0;
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
+        return 0;
+    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->destOffset))
+        return 0;
+    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
+{
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
+        return 0;
+    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset))
+        return 0;
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
+        return 0;
+    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset))
+        return 0;
+    if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
+{
+    if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_IMAGE_LAYOUT(pStruct->oldLayout))
+        return 0;
+    if (!validate_XGL_IMAGE_LAYOUT(pStruct->newLayout))
+        return 0;
+    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_FORMAT(pStruct->format))
+        return 0;
+    if (!validate_XGL_COMPARE_FUNC(pStruct->depthFunc))
+        return 0;
+    if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->front))
+        return 0;
+    if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->back))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (pStruct->pSamplerImageViews && !xgl_validate_xgl_sampler_image_view_info((const XGL_SAMPLER_IMAGE_VIEW_INFO*)pStruct->pSamplerImageViews))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
+{
+    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->type))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (pStruct->pTypeCount && !xgl_validate_xgl_descriptor_type_count((const XGL_DESCRIPTOR_TYPE_COUNT*)pStruct->pTypeCount))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_QUERY_TYPE(pStruct->queryType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_QUEUE_TYPE(pStruct->queueType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+{
+    if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
+{
+    if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
+{
+    if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->r))
+        return 0;
+    if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->g))
+        return 0;
+    if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->b))
+        return 0;
+    if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->a))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
+{
+    if (!xgl_validate_xgl_clear_color_value((const XGL_CLEAR_COLOR_VALUE*)&pStruct->color))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType))
+        return 0;
+    if (!validate_XGL_FORMAT(pStruct->format))
+        return 0;
+    if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
+        return 0;
+    return 1;
+}
 uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
@@ -159,50 +687,28 @@
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+    if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
+uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
 {
-    if (!xgl_validate_xgl_clear_color_value((const XGL_CLEAR_COLOR_VALUE*)&pStruct->color))
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->imageSubresource))
+        return 0;
+    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->imageOffset))
+        return 0;
+    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->imageExtent))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments))
-        return 0;
-    if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
-{
-    if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
-{
     return 1;
 }
 uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
@@ -211,30 +717,6 @@
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues))
-        return 0;
-    if (!validate_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
-{
-    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
-        return 0;
-    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset))
-        return 0;
-    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
-        return 0;
-    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset))
-        return 0;
-    if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
-        return 0;
-    return 1;
-}
 uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
@@ -243,13 +725,7 @@
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
@@ -259,196 +735,6 @@
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
-{
-    if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType))
-        return 0;
-    if (!validate_XGL_FORMAT(pStruct->format))
-        return 0;
-    if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_LOGIC_OP(pStruct->logicOp))
-        return 0;
-    if (pStruct->pAttachments && !xgl_validate_xgl_pipeline_cb_attachment_state((const XGL_PIPELINE_CB_ATTACHMENT_STATE*)pStruct->pAttachments))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
-{
-    if (pStruct->pImageView && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageView))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (pStruct->pTypeCount && !xgl_validate_xgl_descriptor_type_count((const XGL_DESCRIPTOR_TYPE_COUNT*)pStruct->pTypeCount))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
-        return 0;
-    if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->shader))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
-{
-    if (!validate_XGL_FORMAT(pStruct->format))
-        return 0;
-    if (!validate_XGL_BLEND(pStruct->srcBlendColor))
-        return 0;
-    if (!validate_XGL_BLEND(pStruct->destBlendColor))
-        return 0;
-    if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor))
-        return 0;
-    if (!validate_XGL_BLEND(pStruct->srcBlendAlpha))
-        return 0;
-    if (!validate_XGL_BLEND(pStruct->destBlendAlpha))
-        return 0;
-    if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_QUEUE_TYPE(pStruct->queueType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin))
-        return 0;
-    if (!validate_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex))
-        return 0;
-    if (!validate_XGL_FILL_MODE(pStruct->fillMode))
-        return 0;
-    if (!validate_XGL_CULL_MODE(pStruct->cullMode))
-        return 0;
-    if (!validate_XGL_FACE_ORIENTATION(pStruct->frontFace))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_FORMAT(pStruct->format))
-        return 0;
-    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
-        return 0;
-    return 1;
-}
 uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
 {
     if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->subresource))
@@ -459,48 +745,50 @@
         return 0;
     return 1;
 }
+uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+{
+    if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
+{
+    if (!validate_XGL_PIPELINE_SHADER_STAGE(pStruct->stage))
+        return 0;
+    if (pStruct->pLinkConstBufferInfo && !xgl_validate_xgl_link_const_buffer((const XGL_LINK_CONST_BUFFER*)pStruct->pLinkConstBufferInfo))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+        return 0;
+    return 1;
+}
+uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
+{
+    if (pStruct->pImageView && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageView))
+        return 0;
+    return 1;
+}
 uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
 {
     if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!validate_XGL_IMAGE_VIEW_TYPE(pStruct->viewType))
-        return 0;
-    if (!validate_XGL_FORMAT(pStruct->format))
-        return 0;
-    if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
-        return 0;
-    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
-{
-    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
-        return 0;
-    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->srcOffset))
-        return 0;
-    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
-        return 0;
-    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->destOffset))
-        return 0;
-    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
-        return 0;
     return 1;
 }
 uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
@@ -513,64 +801,10 @@
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!validate_XGL_IMAGE_LAYOUT(pStruct->oldLayout))
-        return 0;
-    if (!validate_XGL_IMAGE_LAYOUT(pStruct->newLayout))
-        return 0;
-    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
-{
-    if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->r))
-        return 0;
-    if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->g))
-        return 0;
-    if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->b))
-        return 0;
-    if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->a))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (pStruct->pViewports && !xgl_validate_xgl_viewport((const XGL_VIEWPORT*)pStruct->pViewports))
-        return 0;
-    if (pStruct->pScissors && !xgl_validate_xgl_rect((const XGL_RECT*)pStruct->pScissors))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
-{
     return 1;
 }
 uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
@@ -591,263 +825,29 @@
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct)
-{
-    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset))
-        return 0;
-    if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_FORMAT(pStruct->format))
-        return 0;
-    if (!validate_XGL_COMPARE_FUNC(pStruct->depthFunc))
-        return 0;
-    if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->front))
-        return 0;
-    if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->back))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
-{
-    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->type))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (pStruct->pSamplerImageViews && !xgl_validate_xgl_sampler_image_view_info((const XGL_SAMPLER_IMAGE_VIEW_INFO*)pStruct->pSamplerImageViews))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_QUERY_TYPE(pStruct->queryType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
+uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
     if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
         return 0;
-    if (pStruct->pBufferViews && !xgl_validate_xgl_buffer_view_attach_info((const XGL_BUFFER_VIEW_ATTACH_INFO*)pStruct->pBufferViews))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (pStruct->pVertexBindingDescriptions && !xgl_validate_xgl_vertex_input_binding_description((const XGL_VERTEX_INPUT_BINDING_DESCRIPTION*)pStruct->pVertexBindingDescriptions))
-        return 0;
-    if (pStruct->pVertexAttributeDescriptions && !xgl_validate_xgl_vertex_input_attribute_description((const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*)pStruct->pVertexAttributeDescriptions))
-        return 0;
     return 1;
 }
 uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+    if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
+        return 0;
+    if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
 {
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
-{
-    if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
-{
-    if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
-{
-    if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
-        return 0;
-    if (pStruct->pImageViews && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageViews))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
-{
-    if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp))
-        return 0;
-    if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp))
-        return 0;
-    if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp))
-        return 0;
-    if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
-{
-    if (!validate_XGL_PIPELINE_SHADER_STAGE(pStruct->stage))
-        return 0;
-    if (pStruct->pLinkConstBufferInfo && !xgl_validate_xgl_link_const_buffer((const XGL_LINK_CONST_BUFFER*)pStruct->pLinkConstBufferInfo))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
-{
-    if (!validate_XGL_FORMAT(pStruct->format))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
-{
-    if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_IMAGE_TYPE(pStruct->imageType))
-        return 0;
-    if (!validate_XGL_FORMAT(pStruct->format))
-        return 0;
-    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
-        return 0;
-    if (!validate_XGL_IMAGE_TILING(pStruct->tiling))
-        return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
     return 1;
 }
\ No newline at end of file
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp
index 8cbe8bd..90ba170 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp
@@ -400,143 +400,585 @@
 }
 
 
-// xgl_format_properties_struct_wrapper class definition
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_ia_state_create_info_struct_wrapper class definition
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
+xgl_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_format_properties_struct_wrapper::display_single_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_format_properties_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %slinearTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linearTilingFeatures));
-    printf("%*s    %soptimalTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTilingFeatures));
-}
-
-// Output all struct elements, each on their own line
-void xgl_format_properties_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_format_properties_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_buffer_image_copy_struct_wrapper class definition
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_image_copy_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_BUFFER_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_image_copy_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sbufferOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferOffset));
-    printf("%*s    %simageSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageSubresource));
-    printf("%*s    %simageOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageOffset));
-    printf("%*s    %simageExtent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageExtent));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_image_copy_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_image_copy_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (&m_struct.imageExtent) {
-        xgl_extent3d_struct_wrapper class0(&m_struct.imageExtent);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    if (&m_struct.imageOffset) {
-        xgl_offset3d_struct_wrapper class1(&m_struct.imageOffset);
-        class1.set_indent(m_indent + 4);
-        class1.display_full_txt();
-    }
-    if (&m_struct.imageSubresource) {
-        xgl_image_subresource_struct_wrapper class2(&m_struct.imageSubresource);
-        class2.set_indent(m_indent + 4);
-        class2.display_full_txt();
-    }
-}
-
-
-// xgl_peer_memory_open_info_struct_wrapper class definition
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_peer_memory_open_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_struct_members()
 {
     printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
     printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %soriginalMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalMem));
+    printf("%*s    %stopology = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PRIMITIVE_TOPOLOGY(m_struct.topology));
+    printf("%*s    %sdisableVertexReuse = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.disableVertexReuse) ? "TRUE" : "FALSE");
+    printf("%*s    %sprimitiveRestartEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %sprimitiveRestartIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartIndex));
 }
 
 // Output all struct elements, each on their own line
-void xgl_peer_memory_open_info_struct_wrapper::display_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_peer_memory_open_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_application_info_struct_wrapper class definition
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_application_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_APPLICATION_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_application_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName));
+    printf("%*s    %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion));
+    printf("%*s    %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName));
+    printf("%*s    %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion));
+    printf("%*s    %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
+}
+
+// Output all struct elements, each on their own line
+void xgl_application_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_application_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_link_const_buffer_struct_wrapper class definition
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_link_const_buffer_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_LINK_CONST_BUFFER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_link_const_buffer_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sbufferId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bufferId));
+    printf("%*s    %sbufferSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferSize));
+    printf("%*s    %spBufferData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pBufferData));
+}
+
+// Output all struct elements, each on their own line
+void xgl_link_const_buffer_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_link_const_buffer_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_update_samplers_struct_wrapper class definition
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_update_samplers_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_UPDATE_SAMPLERS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_update_samplers_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+        printf("%*s    %spSamplers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pSamplers)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_update_samplers_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_update_samplers_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_stencil_op_state_struct_wrapper class definition
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_stencil_op_state_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_STENCIL_OP_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_stencil_op_state_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sstencilFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilFailOp));
+    printf("%*s    %sstencilPassOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilPassOp));
+    printf("%*s    %sstencilDepthFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilDepthFailOp));
+    printf("%*s    %sstencilFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.stencilFunc));
+}
+
+// Output all struct elements, each on their own line
+void xgl_stencil_op_state_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_stencil_op_state_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_peer_image_open_info_struct_wrapper class definition
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PEER_IMAGE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_peer_image_open_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage));
+}
+
+// Output all struct elements, each on their own line
+void xgl_peer_image_open_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_peer_image_open_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_device_create_info_struct_wrapper class definition
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_device_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DEVICE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_device_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %squeueRecordCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueRecordCount));
+    uint32_t i;
+    for (i = 0; i<queueRecordCount; i++) {
+        printf("%*s    %spRequestedQueues[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pRequestedQueues)[i]);
+    }
+    printf("%*s    %sextensionCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.extensionCount));
+    for (i = 0; i<extensionCount; i++) {
+        printf("%*s    %sppEnabledExtensionNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppEnabledExtensionNames)[0]);
+    }
+    printf("%*s    %smaxValidationLevel = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VALIDATION_LEVEL(m_struct.maxValidationLevel));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_device_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_device_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    uint32_t i;
+    for (i = 0; i<queueRecordCount; i++) {
+            xgl_device_queue_create_info_struct_wrapper class0(&(m_struct.pRequestedQueues[i]));
+            class0.set_indent(m_indent + 4);
+            class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_buffer_memory_requirements_struct_wrapper class definition
+xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_requirements_struct_wrapper::~xgl_buffer_memory_requirements_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_memory_requirements_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_BUFFER_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_memory_requirements_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_memory_requirements_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_memory_requirements_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_update_buffers_struct_wrapper class definition
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_update_buffers_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_UPDATE_BUFFERS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_update_buffers_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+    printf("%*s    %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+        printf("%*s    %spBufferViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pBufferViews)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_update_buffers_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_update_buffers_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+            xgl_buffer_view_attach_info_struct_wrapper class0(&(m_struct.pBufferViews[i]));
+            class0.set_indent(m_indent + 4);
+            class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_vertex_input_attribute_description_struct_wrapper class definition
+xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_vertex_input_attribute_description_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_vertex_input_attribute_description_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sbinding = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.binding));
+    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+    printf("%*s    %soffsetInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offsetInBytes));
+}
+
+// Output all struct elements, each on their own line
+void xgl_vertex_input_attribute_description_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_vertex_input_attribute_description_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_pipeline_vertex_input_create_info_struct_wrapper class definition
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_vertex_input_create_info_struct_wrapper::~xgl_pipeline_vertex_input_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sbindingCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bindingCount));
+    uint32_t i;
+    for (i = 0; i<bindingCount; i++) {
+        printf("%*s    %spVertexBindingDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexBindingDescriptions)[i]);
+    }
+    printf("%*s    %sattributeCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attributeCount));
+    for (i = 0; i<attributeCount; i++) {
+        printf("%*s    %spVertexAttributeDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexAttributeDescriptions)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    uint32_t i;
+    for (i = 0; i<attributeCount; i++) {
+            xgl_vertex_input_attribute_description_struct_wrapper class0(&(m_struct.pVertexAttributeDescriptions[i]));
+            class0.set_indent(m_indent + 4);
+            class0.display_full_txt();
+    }
+    for (i = 0; i<bindingCount; i++) {
+            xgl_vertex_input_binding_description_struct_wrapper class1(&(m_struct.pVertexBindingDescriptions[i]));
+            class1.set_indent(m_indent + 4);
+            class1.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_dynamic_rs_state_create_info_struct_wrapper class definition
+xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_dynamic_rs_state_create_info_struct_wrapper::~xgl_dynamic_rs_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DYNAMIC_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sdepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBias));
+    printf("%*s    %sdepthBiasClamp = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBiasClamp));
+    printf("%*s    %sslopeScaledDepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.slopeScaledDepthBias));
+    printf("%*s    %spointSize = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointSize));
+    printf("%*s    %spointFadeThreshold = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointFadeThreshold));
+    printf("%*s    %slineWidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.lineWidth));
+}
+
+// Output all struct elements, each on their own line
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -587,105 +1029,6 @@
 }
 
 
-// xgl_physical_gpu_queue_properties_struct_wrapper class definition
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %squeueFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueFlags));
-    printf("%*s    %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
-    printf("%*s    %smaxAtomicCounters = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAtomicCounters));
-    printf("%*s    %ssupportsTimestamps = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsTimestamps) ? "TRUE" : "FALSE");
-}
-
-// Output all struct elements, each on their own line
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_sampler_create_info_struct_wrapper class definition
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_sampler_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_SAMPLER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_sampler_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %smagFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.magFilter));
-    printf("%*s    %sminFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.minFilter));
-    printf("%*s    %smipMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_MIPMAP_MODE(m_struct.mipMode));
-    printf("%*s    %saddressU = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressU));
-    printf("%*s    %saddressV = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressV));
-    printf("%*s    %saddressW = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressW));
-    printf("%*s    %smipLodBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLodBias));
-    printf("%*s    %smaxAnisotropy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAnisotropy));
-    printf("%*s    %scompareFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.compareFunc));
-    printf("%*s    %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
-    printf("%*s    %smaxLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxLod));
-    printf("%*s    %sborderColorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BORDER_COLOR_TYPE(m_struct.borderColorType));
-}
-
-// Output all struct elements, each on their own line
-void xgl_sampler_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_sampler_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
 // xgl_draw_indexed_indirect_cmd_struct_wrapper class definition
 xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
 xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -730,47 +1073,109 @@
 }
 
 
-// xgl_update_as_copy_struct_wrapper class definition
-xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_dynamic_vp_state_create_info_struct_wrapper class definition
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {}
+xgl_dynamic_vp_state_create_info_struct_wrapper::~xgl_dynamic_vp_state_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_update_as_copy_struct_wrapper::display_single_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_UPDATE_AS_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_DYNAMIC_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_update_as_copy_struct_wrapper::display_struct_members()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_struct_members()
 {
     printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
     printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
-    printf("%*s    %sdescriptorSet = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.descriptorSet));
-    printf("%*s    %sdescriptorIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.descriptorIndex));
-    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+    printf("%*s    %sviewportAndScissorCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.viewportAndScissorCount));
+    uint32_t i;
+    for (i = 0; i<viewportAndScissorCount; i++) {
+        printf("%*s    %spViewports[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pViewports)[i]);
+    }
+    for (i = 0; i<viewportAndScissorCount; i++) {
+        printf("%*s    %spScissors[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pScissors)[i]);
+    }
 }
 
 // Output all struct elements, each on their own line
-void xgl_update_as_copy_struct_wrapper::display_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_as_copy_struct_wrapper::display_full_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    uint32_t i;
+    for (i = 0; i<viewportAndScissorCount; i++) {
+            xgl_rect_struct_wrapper class0(&(m_struct.pScissors[i]));
+            class0.set_indent(m_indent + 4);
+            class0.display_full_txt();
+    }
+    for (i = 0; i<viewportAndScissorCount; i++) {
+            xgl_viewport_struct_wrapper class1(&(m_struct.pViewports[i]));
+            class1.set_indent(m_indent + 4);
+            class1.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_shader_create_info_struct_wrapper class definition
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_shader_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_SHADER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_shader_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %scodeSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.codeSize));
+    printf("%*s    %spCode = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pCode));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_shader_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_shader_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -778,93 +1183,521 @@
 }
 
 
-// xgl_clear_color_struct_wrapper class definition
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_memory_ref_struct_wrapper class definition
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {}
+xgl_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_clear_color_struct_wrapper::display_single_txt()
+void xgl_memory_ref_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CLEAR_COLOR = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_MEMORY_REF = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_clear_color_struct_wrapper::display_struct_members()
+void xgl_memory_ref_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %scolor = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.color));
-    printf("%*s    %suseRawValue = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.useRawValue) ? "TRUE" : "FALSE");
+    printf("%*s    %smem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.mem));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
 }
 
 // Output all struct elements, each on their own line
-void xgl_clear_color_struct_wrapper::display_txt()
+void xgl_memory_ref_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_clear_color_struct_wrapper::display_full_txt()
+void xgl_memory_ref_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    if (&m_struct.color) {
-        xgl_clear_color_value_struct_wrapper class0(&m_struct.color);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
+}
+
+
+// xgl_format_properties_struct_wrapper class definition
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_format_properties_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_format_properties_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %slinearTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linearTilingFeatures));
+    printf("%*s    %soptimalTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTilingFeatures));
+}
+
+// Output all struct elements, each on their own line
+void xgl_format_properties_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_format_properties_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_pipeline_statistics_data_struct_wrapper class definition
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_statistics_data_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sfsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.fsInvocations));
+    printf("%*s    %scPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cPrimitives));
+    printf("%*s    %scInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cInvocations));
+    printf("%*s    %svsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.vsInvocations));
+    printf("%*s    %sgsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsInvocations));
+    printf("%*s    %sgsPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsPrimitives));
+    printf("%*s    %siaPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaPrimitives));
+    printf("%*s    %siaVertices = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaVertices));
+    printf("%*s    %stcsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tcsInvocations));
+    printf("%*s    %stesInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tesInvocations));
+    printf("%*s    %scsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.csInvocations));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_statistics_data_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_alloc_callbacks_struct_wrapper class definition
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_ALLOC_CALLBACKS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_alloc_callbacks_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %spUserData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pUserData));
+    printf("%*s    %spfnAlloc = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnAlloc));
+    printf("%*s    %spfnFree = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnFree));
+}
+
+// Output all struct elements, each on their own line
+void xgl_alloc_callbacks_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_alloc_callbacks_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_pipeline_cb_state_create_info_struct_wrapper class definition
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %salphaToCoverageEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.alphaToCoverageEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %slogicOpEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.logicOpEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %slogicOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_LOGIC_OP(m_struct.logicOp));
+    printf("%*s    %sattachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attachmentCount));
+    uint32_t i;
+    for (i = 0; i<attachmentCount; i++) {
+        printf("%*s    %spAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pAttachments)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    uint32_t i;
+    for (i = 0; i<attachmentCount; i++) {
+            xgl_pipeline_cb_attachment_state_struct_wrapper class0(&(m_struct.pAttachments[i]));
+            class0.set_indent(m_indent + 4);
+            class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
     }
 }
 
 
-// xgl_extent2d_struct_wrapper class definition
-xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_draw_indirect_cmd_struct_wrapper class definition
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_extent2d_struct_wrapper::~xgl_extent2d_struct_wrapper() {}
+xgl_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_extent2d_struct_wrapper::display_single_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_EXTENT2D = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_DRAW_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_extent2d_struct_wrapper::display_struct_members()
+void xgl_draw_indirect_cmd_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
-    printf("%*s    %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+    printf("%*s    %svertexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexCount));
+    printf("%*s    %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
+    printf("%*s    %sfirstVertex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstVertex));
+    printf("%*s    %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
 }
 
 // Output all struct elements, each on their own line
-void xgl_extent2d_struct_wrapper::display_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_extent2d_struct_wrapper::display_full_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 
+// xgl_color_attachment_view_create_info_struct_wrapper class definition
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_color_attachment_view_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+    printf("%*s    %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+    printf("%*s    %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+    printf("%*s    %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+    printf("%*s    %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
+    printf("%*s    %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_attachment_view_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_attachment_view_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.msaaResolveSubResource) {
+        xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_pipeline_cb_attachment_state_struct_wrapper class definition
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_CB_ATTACHMENT_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sblendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.blendEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+    printf("%*s    %ssrcBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendColor));
+    printf("%*s    %sdestBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendColor));
+    printf("%*s    %sblendFuncColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncColor));
+    printf("%*s    %ssrcBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendAlpha));
+    printf("%*s    %sdestBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendAlpha));
+    printf("%*s    %sblendFuncAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncAlpha));
+    printf("%*s    %schannelWriteMask = %hu\n", m_indent, "", &m_dummy_prefix, (m_struct.channelWriteMask));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_vertex_input_binding_description_struct_wrapper class definition
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_vertex_input_binding_description_struct_wrapper::~xgl_vertex_input_binding_description_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_vertex_input_binding_description_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_vertex_input_binding_description_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sstrideInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.strideInBytes));
+    printf("%*s    %sstepRate = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VERTEX_INPUT_STEP_RATE(m_struct.stepRate));
+}
+
+// Output all struct elements, each on their own line
+void xgl_vertex_input_binding_description_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_vertex_input_binding_description_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_pipeline_shader_stage_create_info_struct_wrapper class definition
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.shader));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.shader) {
+        xgl_pipeline_shader_struct_wrapper class0(&m_struct.shader);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_fence_create_info_struct_wrapper class definition
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_fence_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_fence_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_fence_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_fence_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
 // xgl_framebuffer_create_info_struct_wrapper class definition
 xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
 xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -930,1127 +1763,186 @@
 }
 
 
-// xgl_alloc_callbacks_struct_wrapper class definition
-xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_extent2d_struct_wrapper class definition
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
+xgl_extent2d_struct_wrapper::~xgl_extent2d_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
+void xgl_extent2d_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_ALLOC_CALLBACKS = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_EXTENT2D = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_alloc_callbacks_struct_wrapper::display_struct_members()
+void xgl_extent2d_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %spUserData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pUserData));
-    printf("%*s    %spfnAlloc = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnAlloc));
-    printf("%*s    %spfnFree = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnFree));
+    printf("%*s    %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+    printf("%*s    %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
 }
 
 // Output all struct elements, each on their own line
-void xgl_alloc_callbacks_struct_wrapper::display_txt()
+void xgl_extent2d_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_alloc_callbacks_struct_wrapper::display_full_txt()
+void xgl_extent2d_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 
-// xgl_memory_requirements_struct_wrapper class definition
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_compute_pipeline_create_info_struct_wrapper class definition
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {}
+xgl_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_memory_requirements_struct_wrapper::display_single_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_COMPUTE_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_memory_requirements_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
-    printf("%*s    %salignment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.alignment));
-    printf("%*s    %sgranularity = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.granularity));
-    printf("%*s    %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
-    printf("%*s    %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_requirements_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_requirements_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_link_const_buffer_struct_wrapper class definition
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_link_const_buffer_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_LINK_CONST_BUFFER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_link_const_buffer_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sbufferId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bufferId));
-    printf("%*s    %sbufferSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferSize));
-    printf("%*s    %spBufferData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pBufferData));
-}
-
-// Output all struct elements, each on their own line
-void xgl_link_const_buffer_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_link_const_buffer_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_physical_gpu_properties_struct_wrapper class definition
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_properties_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_properties_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
-    printf("%*s    %sdriverVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.driverVersion));
-    printf("%*s    %svendorId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vendorId));
-    printf("%*s    %sdeviceId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.deviceId));
-    printf("%*s    %sgpuType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PHYSICAL_GPU_TYPE(m_struct.gpuType));
-    uint32_t i;
-    for (i = 0; i<XGL_MAX_PHYSICAL_GPU_NAME; i++) {
-        printf("%*s    %sgpuName = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuName));
-    }
-    printf("%*s    %smaxMemRefsPerSubmission = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxMemRefsPerSubmission));
-    printf("%*s    %smaxInlineMemoryUpdateSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.maxInlineMemoryUpdateSize));
-    printf("%*s    %smaxBoundDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxBoundDescriptorSets));
-    printf("%*s    %smaxThreadGroupSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxThreadGroupSize));
-    printf("%*s    %stimestampFrequency = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.timestampFrequency));
-    printf("%*s    %smultiColorAttachmentClears = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.multiColorAttachmentClears) ? "TRUE" : "FALSE");
-    printf("%*s    %smaxDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDescriptorSets));
-    printf("%*s    %smaxViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxViewports));
-    printf("%*s    %smaxColorAttachments = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxColorAttachments));
-}
-
-// Output all struct elements, each on their own line
-void xgl_physical_gpu_properties_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_properties_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_device_create_info_struct_wrapper class definition
-xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_device_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DEVICE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_device_create_info_struct_wrapper::display_struct_members()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_struct_members()
 {
     printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
     printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %squeueRecordCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueRecordCount));
-    uint32_t i;
-    for (i = 0; i<queueRecordCount; i++) {
-        printf("%*s    %spRequestedQueues[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pRequestedQueues)[i]);
-    }
-    printf("%*s    %sextensionCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.extensionCount));
-    for (i = 0; i<extensionCount; i++) {
-        printf("%*s    %sppEnabledExtensionNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppEnabledExtensionNames)[0]);
-    }
-    printf("%*s    %smaxValidationLevel = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VALIDATION_LEVEL(m_struct.maxValidationLevel));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_device_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_device_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<queueRecordCount; i++) {
-            xgl_device_queue_create_info_struct_wrapper class0(&(m_struct.pRequestedQueues[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_image_resolve_struct_wrapper class definition
-xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_resolve_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_IMAGE_RESOLVE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_resolve_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
-    printf("%*s    %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
-    printf("%*s    %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
-    printf("%*s    %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
-    printf("%*s    %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_resolve_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_resolve_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (&m_struct.extent) {
-        xgl_extent2d_struct_wrapper class0(&m_struct.extent);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    if (&m_struct.destOffset) {
-        xgl_offset2d_struct_wrapper class1(&m_struct.destOffset);
-        class1.set_indent(m_indent + 4);
-        class1.display_full_txt();
-    }
-    if (&m_struct.destSubresource) {
-        xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
-        class2.set_indent(m_indent + 4);
-        class2.display_full_txt();
-    }
-    if (&m_struct.srcOffset) {
-        xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset);
-        class3.set_indent(m_indent + 4);
-        class3.display_full_txt();
-    }
-    if (&m_struct.srcSubresource) {
-        xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
-        class4.set_indent(m_indent + 4);
-        class4.display_full_txt();
-    }
-}
-
-
-// xgl_image_view_attach_info_struct_wrapper class definition
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_view_attach_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_IMAGE_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_view_attach_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
-    printf("%*s    %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_view_attach_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_fence_create_info_struct_wrapper class definition
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_fence_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_fence_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_fence_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_fence_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_dynamic_rs_state_create_info_struct_wrapper class definition
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dynamic_rs_state_create_info_struct_wrapper::~xgl_dynamic_rs_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DYNAMIC_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sdepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBias));
-    printf("%*s    %sdepthBiasClamp = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBiasClamp));
-    printf("%*s    %sslopeScaledDepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.slopeScaledDepthBias));
-    printf("%*s    %spointSize = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointSize));
-    printf("%*s    %spointFadeThreshold = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointFadeThreshold));
-    printf("%*s    %slineWidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.lineWidth));
-}
-
-// Output all struct elements, each on their own line
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_buffer_copy_struct_wrapper class definition
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_copy_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_BUFFER_COPY = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_copy_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.srcOffset));
-    printf("%*s    %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.destOffset));
-    printf("%*s    %scopySize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.copySize));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_copy_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_copy_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_color_attachment_bind_info_struct_wrapper class definition
-xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_COLOR_ATTACHMENT_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_color_attachment_bind_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
-    printf("%*s    %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
-}
-
-// Output all struct elements, each on their own line
-void xgl_color_attachment_bind_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_buffer_view_create_info_struct_wrapper class definition
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_view_create_info_struct_wrapper::~xgl_buffer_view_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_view_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_BUFFER_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_view_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
-    printf("%*s    %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BUFFER_VIEW_TYPE(m_struct.viewType));
-    printf("%*s    %sstride = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.stride));
-    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
-    printf("%*s    %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
-    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
-    printf("%*s    %srange = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.range));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_view_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_view_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (&m_struct.channels) {
-        xgl_channel_mapping_struct_wrapper class0(&m_struct.channels);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_queue_semaphore_open_info_struct_wrapper class definition
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_queue_semaphore_open_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %ssharedSemaphore = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedSemaphore));
-}
-
-// Output all struct elements, each on their own line
-void xgl_queue_semaphore_open_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_pipeline_cb_state_create_info_struct_wrapper class definition
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %salphaToCoverageEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.alphaToCoverageEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %slogicOpEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.logicOpEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %slogicOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_LOGIC_OP(m_struct.logicOp));
-    printf("%*s    %sattachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attachmentCount));
-    uint32_t i;
-    for (i = 0; i<attachmentCount; i++) {
-        printf("%*s    %spAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pAttachments)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<attachmentCount; i++) {
-            xgl_pipeline_cb_attachment_state_struct_wrapper class0(&(m_struct.pAttachments[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_dynamic_cb_state_create_info_struct_wrapper class definition
-xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dynamic_cb_state_create_info_struct_wrapper::~xgl_dynamic_cb_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DYNAMIC_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    uint32_t i;
-    for (i = 0; i<4; i++) {
-        printf("%*s    %sblendConst[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.blendConst)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_buffer_memory_requirements_struct_wrapper class definition
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_memory_requirements_struct_wrapper::~xgl_buffer_memory_requirements_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_memory_requirements_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_BUFFER_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_memory_requirements_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_memory_requirements_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_memory_requirements_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_sampler_image_view_info_struct_wrapper class definition
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_sampler_image_view_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_SAMPLER_IMAGE_VIEW_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_sampler_image_view_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %spSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pSampler));
-    printf("%*s    %spImageView = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pImageView));
-}
-
-// Output all struct elements, each on their own line
-void xgl_sampler_image_view_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_sampler_image_view_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pImageView) {
-        xgl_image_view_attach_info_struct_wrapper class0(m_struct.pImageView);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-}
-
-
-// xgl_descriptor_set_layout_create_info_struct_wrapper class definition
-xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_descriptor_set_layout_create_info_struct_wrapper::~xgl_descriptor_set_layout_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
-    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
-    printf("%*s    %sstageFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stageFlags));
-    printf("%*s    %simmutableSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.immutableSampler));
-}
-
-// Output all struct elements, each on their own line
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_event_wait_info_struct_wrapper class definition
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_event_wait_info_struct_wrapper::~xgl_event_wait_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_event_wait_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_EVENT_WAIT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_event_wait_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
-    uint32_t i;
-    for (i = 0; i<eventCount; i++) {
-        printf("%*s    %spEvents[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pEvents)[i]);
-    }
-    printf("%*s    %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
-    printf("%*s    %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
-    for (i = 0; i<memBarrierCount; i++) {
-        printf("%*s    %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_event_wait_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_event_wait_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_descriptor_region_create_info_struct_wrapper class definition
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DESCRIPTOR_REGION_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_descriptor_region_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-        printf("%*s    %spTypeCount[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pTypeCount)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_descriptor_region_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_region_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-            xgl_descriptor_type_count_struct_wrapper class0(&(m_struct.pTypeCount[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_memory_alloc_info_struct_wrapper class definition
-xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_alloc_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sallocationSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.allocationSize));
-    printf("%*s    %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
-    printf("%*s    %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
-    printf("%*s    %smemPriority = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_PRIORITY(m_struct.memPriority));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_alloc_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_alloc_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_memory_open_info_struct_wrapper class definition
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_open_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_open_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_open_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_open_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_graphics_pipeline_create_info_struct_wrapper class definition
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %scs = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.cs));
     printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
     printf("%*s    %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
+    printf("%*s    %slocalSizeX = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeX));
+    printf("%*s    %slocalSizeY = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeY));
+    printf("%*s    %slocalSizeZ = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeZ));
 }
 
 // Output all struct elements, each on their own line
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.cs) {
+        xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_image_subresource_range_struct_wrapper class definition
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_subresource_range_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_subresource_range_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
+    printf("%*s    %sbaseMipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseMipLevel));
+    printf("%*s    %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
+    printf("%*s    %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+    printf("%*s    %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_subresource_range_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_subresource_range_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_pipeline_tess_state_create_info_struct_wrapper class definition
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %spatchControlPoints = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.patchControlPoints));
+    printf("%*s    %soptimalTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTessFactor));
+    printf("%*s    %sfixedTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.fixedTessFactor));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -2058,50 +1950,182 @@
 }
 
 
-// xgl_pipeline_shader_stage_create_info_struct_wrapper class definition
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_offset2d_struct_wrapper class definition
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {}
+xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
+void xgl_offset2d_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_OFFSET2D = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members()
+void xgl_offset2d_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.shader));
+    printf("%*s    %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+    printf("%*s    %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
 }
 
 // Output all struct elements, each on their own line
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
+void xgl_offset2d_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
+void xgl_offset2d_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    if (&m_struct.shader) {
-        xgl_pipeline_shader_struct_wrapper class0(&m_struct.shader);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
+}
+
+
+// xgl_queue_semaphore_create_info_struct_wrapper class definition
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_QUEUE_SEMAPHORE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_queue_semaphore_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sinitialCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.initialCount));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_queue_semaphore_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
     }
+}
+
+
+// xgl_clear_color_value_struct_wrapper class definition
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_clear_color_value_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_CLEAR_COLOR_VALUE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_clear_color_value_struct_wrapper::display_struct_members()
+{
+    uint32_t i;
+    for (i = 0; i<4; i++) {
+        printf("%*s    %sfloatColor[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.floatColor)[i]);
+    }
+    for (i = 0; i<4; i++) {
+        printf("%*s    %srawColor[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.rawColor)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_clear_color_value_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_clear_color_value_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_buffer_memory_barrier_struct_wrapper class definition
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_memory_barrier_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
+    printf("%*s    %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
+    printf("%*s    %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
+    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
+    printf("%*s    %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_memory_barrier_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
     }
@@ -2157,297 +2181,6 @@
 }
 
 
-// xgl_pipeline_barrier_struct_wrapper class definition
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_barrier_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_barrier_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
-    uint32_t i;
-    for (i = 0; i<eventCount; i++) {
-        printf("%*s    %spEvents[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_SET_EVENT(*m_struct.pEvents)[i]);
-    }
-    printf("%*s    %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
-    printf("%*s    %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
-    for (i = 0; i<memBarrierCount; i++) {
-        printf("%*s    %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_barrier_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_barrier_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_memory_barrier_struct_wrapper class definition
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_barrier_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_barrier_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
-    printf("%*s    %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_barrier_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_barrier_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_pipeline_ia_state_create_info_struct_wrapper class definition
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %stopology = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PRIMITIVE_TOPOLOGY(m_struct.topology));
-    printf("%*s    %sdisableVertexReuse = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.disableVertexReuse) ? "TRUE" : "FALSE");
-    printf("%*s    %sprimitiveRestartEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %sprimitiveRestartIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartIndex));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_pipeline_cb_attachment_state_struct_wrapper class definition
-xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_CB_ATTACHMENT_STATE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sblendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.blendEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
-    printf("%*s    %ssrcBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendColor));
-    printf("%*s    %sdestBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendColor));
-    printf("%*s    %sblendFuncColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncColor));
-    printf("%*s    %ssrcBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendAlpha));
-    printf("%*s    %sdestBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendAlpha));
-    printf("%*s    %sblendFuncAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncAlpha));
-    printf("%*s    %schannelWriteMask = %hu\n", m_indent, "", &m_dummy_prefix, (m_struct.channelWriteMask));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_cmd_buffer_create_info_struct_wrapper class definition
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %squeueType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUEUE_TYPE(m_struct.queueType));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_cmd_buffer_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_application_info_struct_wrapper class definition
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_application_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_APPLICATION_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_application_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName));
-    printf("%*s    %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion));
-    printf("%*s    %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName));
-    printf("%*s    %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion));
-    printf("%*s    %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
-}
-
-// Output all struct elements, each on their own line
-void xgl_application_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_application_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
 // xgl_pipeline_rs_state_create_info_struct_wrapper class definition
 xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
 xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -2500,53 +2233,55 @@
 }
 
 
-// xgl_color_attachment_view_create_info_struct_wrapper class definition
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_create_info_struct_wrapper class definition
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_create_info_struct_wrapper() {}
+xgl_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt()
+void xgl_image_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_color_attachment_view_create_info_struct_wrapper::display_struct_members()
+void xgl_image_create_info_struct_wrapper::display_struct_members()
 {
     printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
     printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+    printf("%*s    %simageType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TYPE(m_struct.imageType));
     printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
-    printf("%*s    %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
-    printf("%*s    %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+    printf("%*s    %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+    printf("%*s    %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
     printf("%*s    %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
-    printf("%*s    %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
-    printf("%*s    %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
+    printf("%*s    %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+    printf("%*s    %stiling = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TILING(m_struct.tiling));
+    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
 }
 
 // Output all struct elements, each on their own line
-void xgl_color_attachment_view_create_info_struct_wrapper::display_txt()
+void xgl_image_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_color_attachment_view_create_info_struct_wrapper::display_full_txt()
+void xgl_image_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    if (&m_struct.msaaResolveSubResource) {
-        xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
+    if (&m_struct.extent) {
+        xgl_extent3d_struct_wrapper class0(&m_struct.extent);
         class0.set_indent(m_indent + 4);
         class0.display_full_txt();
     }
@@ -2556,145 +2291,105 @@
 }
 
 
-// xgl_image_memory_bind_info_struct_wrapper class definition
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_update_images_struct_wrapper class definition
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_info_struct_wrapper() {}
+xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_memory_bind_info_struct_wrapper::display_single_txt()
+void xgl_update_images_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_MEMORY_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_UPDATE_IMAGES = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_image_memory_bind_info_struct_wrapper::display_struct_members()
+void xgl_update_images_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %ssubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresource));
-    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
-    printf("%*s    %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+    printf("%*s    %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+        printf("%*s    %spImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pImageViews)[i]);
+    }
 }
 
 // Output all struct elements, each on their own line
-void xgl_image_memory_bind_info_struct_wrapper::display_txt()
+void xgl_update_images_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_memory_bind_info_struct_wrapper::display_full_txt()
+void xgl_update_images_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    if (&m_struct.extent) {
-        xgl_extent3d_struct_wrapper class0(&m_struct.extent);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+            xgl_image_view_attach_info_struct_wrapper class0(&(m_struct.pImageViews[i]));
+            class0.set_indent(m_indent + 4);
+            class0.display_full_txt();
     }
-    if (&m_struct.offset) {
-        xgl_offset3d_struct_wrapper class1(&m_struct.offset);
-        class1.set_indent(m_indent + 4);
-        class1.display_full_txt();
-    }
-    if (&m_struct.subresource) {
-        xgl_image_subresource_struct_wrapper class2(&m_struct.subresource);
-        class2.set_indent(m_indent + 4);
-        class2.display_full_txt();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
     }
 }
 
 
-// xgl_image_subresource_struct_wrapper class definition
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_cmd_buffer_begin_info_struct_wrapper class definition
+xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {}
+xgl_cmd_buffer_begin_info_struct_wrapper::~xgl_cmd_buffer_begin_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_subresource_struct_wrapper::display_single_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_SUBRESOURCE = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_CMD_BUFFER_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_image_subresource_struct_wrapper::display_struct_members()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
-    printf("%*s    %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
-    printf("%*s    %sarraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySlice));
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
 }
 
 // Output all struct elements, each on their own line
-void xgl_image_subresource_struct_wrapper::display_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_subresource_struct_wrapper::display_full_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-}
-
-
-// xgl_draw_indirect_cmd_struct_wrapper class definition
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DRAW_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_draw_indirect_cmd_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %svertexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexCount));
-    printf("%*s    %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
-    printf("%*s    %sfirstVertex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstVertex));
-    printf("%*s    %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
-}
-
-// Output all struct elements, each on their own line
-void xgl_draw_indirect_cmd_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_draw_indirect_cmd_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
 }
 
 
@@ -2758,44 +2453,275 @@
 }
 
 
-// xgl_cmd_buffer_begin_info_struct_wrapper class definition
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_graphics_pipeline_create_info_struct_wrapper class definition
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_cmd_buffer_begin_info_struct_wrapper::~xgl_cmd_buffer_begin_info_struct_wrapper() {}
+xgl_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_single_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CMD_BUFFER_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_struct_members()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_struct_members()
 {
     printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
     printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
     printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+    printf("%*s    %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
 }
 
 // Output all struct elements, each on their own line
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_full_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_rect_struct_wrapper class definition
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(const XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_rect_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_rect_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
+    printf("%*s    %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_rect_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_rect_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.extent) {
+        xgl_extent2d_struct_wrapper class0(&m_struct.extent);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (&m_struct.offset) {
+        xgl_offset2d_struct_wrapper class1(&m_struct.offset);
+        class1.set_indent(m_indent + 4);
+        class1.display_full_txt();
+    }
+}
+
+
+// xgl_cmd_buffer_graphics_begin_info_struct_wrapper class definition
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::~xgl_cmd_buffer_graphics_begin_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass));
+}
+
+// Output all struct elements, each on their own line
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_device_queue_create_info_struct_wrapper class definition
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DEVICE_QUEUE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_device_queue_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %squeueNodeIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueNodeIndex));
+    printf("%*s    %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
+}
+
+// Output all struct elements, each on their own line
+void xgl_device_queue_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_device_queue_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_memory_open_info_struct_wrapper class definition
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_open_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_open_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_open_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_open_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_update_as_copy_struct_wrapper class definition
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_update_as_copy_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_UPDATE_AS_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_update_as_copy_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+    printf("%*s    %sdescriptorSet = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.descriptorSet));
+    printf("%*s    %sdescriptorIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.descriptorIndex));
+    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+}
+
+// Output all struct elements, each on their own line
+void xgl_update_as_copy_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_update_as_copy_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -2872,46 +2798,159 @@
 }
 
 
-// xgl_pipeline_vp_state_create_info_struct_wrapper class definition
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_resolve_struct_wrapper class definition
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_pipeline_vp_state_create_info_struct_wrapper::~xgl_pipeline_vp_state_create_info_struct_wrapper() {}
+xgl_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_single_txt()
+void xgl_image_resolve_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_IMAGE_RESOLVE = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_struct_members()
+void xgl_image_resolve_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %snumViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.numViewports));
-    printf("%*s    %sclipOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.clipOrigin));
-    printf("%*s    %sdepthMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DEPTH_MODE(m_struct.depthMode));
+    printf("%*s    %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
+    printf("%*s    %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
+    printf("%*s    %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
+    printf("%*s    %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
+    printf("%*s    %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
 }
 
 // Output all struct elements, each on their own line
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_txt()
+void xgl_image_resolve_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_full_txt()
+void xgl_image_resolve_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.extent) {
+        xgl_extent2d_struct_wrapper class0(&m_struct.extent);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (&m_struct.destOffset) {
+        xgl_offset2d_struct_wrapper class1(&m_struct.destOffset);
+        class1.set_indent(m_indent + 4);
+        class1.display_full_txt();
+    }
+    if (&m_struct.destSubresource) {
+        xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
+        class2.set_indent(m_indent + 4);
+        class2.display_full_txt();
+    }
+    if (&m_struct.srcOffset) {
+        xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset);
+        class3.set_indent(m_indent + 4);
+        class3.display_full_txt();
+    }
+    if (&m_struct.srcSubresource) {
+        xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
+        class4.set_indent(m_indent + 4);
+        class4.display_full_txt();
+    }
+}
+
+
+// xgl_color_attachment_bind_info_struct_wrapper class definition
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_COLOR_ATTACHMENT_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_color_attachment_bind_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+    printf("%*s    %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_attachment_bind_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_dynamic_ds_state_create_info_struct_wrapper class definition
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_dynamic_ds_state_create_info_struct_wrapper::~xgl_dynamic_ds_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DYNAMIC_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
+    printf("%*s    %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
+    printf("%*s    %sstencilReadMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilReadMask));
+    printf("%*s    %sstencilWriteMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilWriteMask));
+    printf("%*s    %sstencilFrontRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilFrontRef));
+    printf("%*s    %sstencilBackRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilBackRef));
+}
+
+// Output all struct elements, each on their own line
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -2974,6 +3013,122 @@
 }
 
 
+// xgl_pipeline_ds_state_create_info_struct_wrapper class definition
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_ds_state_create_info_struct_wrapper::~xgl_pipeline_ds_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+    printf("%*s    %sdepthTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthTestEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %sdepthWriteEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthWriteEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %sdepthFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.depthFunc));
+    printf("%*s    %sdepthBoundsEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBoundsEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %sstencilTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilTestEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %sfront = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.front));
+    printf("%*s    %sback = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.back));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.back) {
+        xgl_stencil_op_state_struct_wrapper class0(&m_struct.back);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (&m_struct.front) {
+        xgl_stencil_op_state_struct_wrapper class1(&m_struct.front);
+        class1.set_indent(m_indent + 4);
+        class1.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_pipeline_barrier_struct_wrapper class definition
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_barrier_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_barrier_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
+    uint32_t i;
+    for (i = 0; i<eventCount; i++) {
+        printf("%*s    %spEvents[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_SET_EVENT(*m_struct.pEvents)[i]);
+    }
+    printf("%*s    %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
+    printf("%*s    %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
+    for (i = 0; i<memBarrierCount; i++) {
+        printf("%*s    %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_barrier_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_barrier_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
 // xgl_physical_gpu_memory_properties_struct_wrapper class definition
 xgl_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
 xgl_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -3015,6 +3170,1214 @@
 }
 
 
+// xgl_memory_alloc_image_info_struct_wrapper class definition
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_memory_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_MEMORY_ALLOC_IMAGE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_alloc_image_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+    printf("%*s    %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
+    printf("%*s    %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_alloc_image_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_update_sampler_textures_struct_wrapper class definition
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_update_sampler_textures_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_update_sampler_textures_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+        printf("%*s    %spSamplerImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pSamplerImageViews)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_update_sampler_textures_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_update_sampler_textures_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+            xgl_sampler_image_view_info_struct_wrapper class0(&(m_struct.pSamplerImageViews[i]));
+            class0.set_indent(m_indent + 4);
+            class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_peer_memory_open_info_struct_wrapper class definition
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_peer_memory_open_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %soriginalMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalMem));
+}
+
+// Output all struct elements, each on their own line
+void xgl_peer_memory_open_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_peer_memory_open_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_descriptor_type_count_struct_wrapper class definition
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_descriptor_type_count_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DESCRIPTOR_TYPE_COUNT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_descriptor_type_count_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %stype = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.type));
+    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+}
+
+// Output all struct elements, each on their own line
+void xgl_descriptor_type_count_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_descriptor_type_count_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_dispatch_indirect_cmd_struct_wrapper class definition
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sx = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+    printf("%*s    %sy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
+    printf("%*s    %sz = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
+}
+
+// Output all struct elements, each on their own line
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_descriptor_region_create_info_struct_wrapper class definition
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DESCRIPTOR_REGION_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_descriptor_region_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+        printf("%*s    %spTypeCount[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pTypeCount)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_descriptor_region_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_descriptor_region_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    uint32_t i;
+    for (i = 0; i<count; i++) {
+            xgl_descriptor_type_count_struct_wrapper class0(&(m_struct.pTypeCount[i]));
+            class0.set_indent(m_indent + 4);
+            class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_viewport_struct_wrapper class definition
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_viewport_struct_wrapper::~xgl_viewport_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_viewport_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_VIEWPORT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_viewport_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %soriginX = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originX));
+    printf("%*s    %soriginY = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originY));
+    printf("%*s    %swidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+    printf("%*s    %sheight = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+    printf("%*s    %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
+    printf("%*s    %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
+}
+
+// Output all struct elements, each on their own line
+void xgl_viewport_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_viewport_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_depth_stencil_view_create_info_struct_wrapper class definition
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+    printf("%*s    %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+    printf("%*s    %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+    printf("%*s    %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+    printf("%*s    %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
+    printf("%*s    %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.msaaResolveSubResource) {
+        xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_query_pool_create_info_struct_wrapper class definition
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_query_pool_create_info_struct_wrapper::~xgl_query_pool_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_QUERY_POOL_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_query_pool_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %squeryType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUERY_TYPE(m_struct.queryType));
+    printf("%*s    %sslots = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slots));
+}
+
+// Output all struct elements, each on their own line
+void xgl_query_pool_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_query_pool_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_cmd_buffer_create_info_struct_wrapper class definition
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_cmd_buffer_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %squeueType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUEUE_TYPE(m_struct.queueType));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_cmd_buffer_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_depth_stencil_bind_info_struct_wrapper class definition
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DEPTH_STENCIL_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_depth_stencil_bind_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+    printf("%*s    %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+}
+
+// Output all struct elements, each on their own line
+void xgl_depth_stencil_bind_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_depth_stencil_bind_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_memory_requirements_struct_wrapper class definition
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_requirements_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_requirements_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+    printf("%*s    %salignment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.alignment));
+    printf("%*s    %sgranularity = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.granularity));
+    printf("%*s    %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
+    printf("%*s    %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_requirements_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_requirements_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_queue_semaphore_open_info_struct_wrapper class definition
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_queue_semaphore_open_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %ssharedSemaphore = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedSemaphore));
+}
+
+// Output all struct elements, each on their own line
+void xgl_queue_semaphore_open_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_memory_barrier_struct_wrapper class definition
+xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_barrier_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_barrier_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
+    printf("%*s    %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_barrier_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_barrier_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_physical_gpu_performance_struct_wrapper class definition
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_physical_gpu_performance_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_physical_gpu_performance_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %smaxGpuClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxGpuClock));
+    printf("%*s    %saluPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.aluPerClock));
+    printf("%*s    %stexPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.texPerClock));
+    printf("%*s    %sprimsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.primsPerClock));
+    printf("%*s    %spixelsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pixelsPerClock));
+}
+
+// Output all struct elements, each on their own line
+void xgl_physical_gpu_performance_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_physical_gpu_performance_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_channel_mapping_struct_wrapper class definition
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_channel_mapping_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_CHANNEL_MAPPING = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_channel_mapping_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sr = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.r));
+    printf("%*s    %sg = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.g));
+    printf("%*s    %sb = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.b));
+    printf("%*s    %sa = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.a));
+}
+
+// Output all struct elements, each on their own line
+void xgl_channel_mapping_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_channel_mapping_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_clear_color_struct_wrapper class definition
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_clear_color_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_CLEAR_COLOR = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_clear_color_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %scolor = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.color));
+    printf("%*s    %suseRawValue = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.useRawValue) ? "TRUE" : "FALSE");
+}
+
+// Output all struct elements, each on their own line
+void xgl_clear_color_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_clear_color_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.color) {
+        xgl_clear_color_value_struct_wrapper class0(&m_struct.color);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+}
+
+
+// xgl_dynamic_cb_state_create_info_struct_wrapper class definition
+xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_dynamic_cb_state_create_info_struct_wrapper::~xgl_dynamic_cb_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_DYNAMIC_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    uint32_t i;
+    for (i = 0; i<4; i++) {
+        printf("%*s    %sblendConst[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.blendConst)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_buffer_view_create_info_struct_wrapper class definition
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_view_create_info_struct_wrapper::~xgl_buffer_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_view_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_BUFFER_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_view_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
+    printf("%*s    %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BUFFER_VIEW_TYPE(m_struct.viewType));
+    printf("%*s    %sstride = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.stride));
+    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+    printf("%*s    %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
+    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
+    printf("%*s    %srange = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.range));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_view_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_view_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.channels) {
+        xgl_channel_mapping_struct_wrapper class0(&m_struct.channels);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_sampler_create_info_struct_wrapper class definition
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_sampler_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_SAMPLER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_sampler_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %smagFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.magFilter));
+    printf("%*s    %sminFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.minFilter));
+    printf("%*s    %smipMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_MIPMAP_MODE(m_struct.mipMode));
+    printf("%*s    %saddressU = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressU));
+    printf("%*s    %saddressV = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressV));
+    printf("%*s    %saddressW = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressW));
+    printf("%*s    %smipLodBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLodBias));
+    printf("%*s    %smaxAnisotropy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAnisotropy));
+    printf("%*s    %scompareFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.compareFunc));
+    printf("%*s    %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
+    printf("%*s    %smaxLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxLod));
+    printf("%*s    %sborderColorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BORDER_COLOR_TYPE(m_struct.borderColorType));
+}
+
+// Output all struct elements, each on their own line
+void xgl_sampler_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_sampler_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_event_wait_info_struct_wrapper class definition
+xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_event_wait_info_struct_wrapper::~xgl_event_wait_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_event_wait_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_EVENT_WAIT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_event_wait_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
+    uint32_t i;
+    for (i = 0; i<eventCount; i++) {
+        printf("%*s    %spEvents[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pEvents)[i]);
+    }
+    printf("%*s    %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
+    printf("%*s    %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
+    for (i = 0; i<memBarrierCount; i++) {
+        printf("%*s    %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_event_wait_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_event_wait_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_buffer_image_copy_struct_wrapper class definition
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_image_copy_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_BUFFER_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_image_copy_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sbufferOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferOffset));
+    printf("%*s    %simageSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageSubresource));
+    printf("%*s    %simageOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageOffset));
+    printf("%*s    %simageExtent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageExtent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_image_copy_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_image_copy_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.imageExtent) {
+        xgl_extent3d_struct_wrapper class0(&m_struct.imageExtent);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (&m_struct.imageOffset) {
+        xgl_offset3d_struct_wrapper class1(&m_struct.imageOffset);
+        class1.set_indent(m_indent + 4);
+        class1.display_full_txt();
+    }
+    if (&m_struct.imageSubresource) {
+        xgl_image_subresource_struct_wrapper class2(&m_struct.imageSubresource);
+        class2.set_indent(m_indent + 4);
+        class2.display_full_txt();
+    }
+}
+
+
+// xgl_event_create_info_struct_wrapper class definition
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_event_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_EVENT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_event_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_event_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_event_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_physical_gpu_properties_struct_wrapper class definition
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_physical_gpu_properties_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_physical_gpu_properties_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
+    printf("%*s    %sdriverVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.driverVersion));
+    printf("%*s    %svendorId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vendorId));
+    printf("%*s    %sdeviceId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.deviceId));
+    printf("%*s    %sgpuType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PHYSICAL_GPU_TYPE(m_struct.gpuType));
+    uint32_t i;
+    for (i = 0; i<XGL_MAX_PHYSICAL_GPU_NAME; i++) {
+        printf("%*s    %sgpuName = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuName));
+    }
+    printf("%*s    %smaxMemRefsPerSubmission = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxMemRefsPerSubmission));
+    printf("%*s    %smaxInlineMemoryUpdateSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.maxInlineMemoryUpdateSize));
+    printf("%*s    %smaxBoundDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxBoundDescriptorSets));
+    printf("%*s    %smaxThreadGroupSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxThreadGroupSize));
+    printf("%*s    %stimestampFrequency = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.timestampFrequency));
+    printf("%*s    %smultiColorAttachmentClears = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.multiColorAttachmentClears) ? "TRUE" : "FALSE");
+    printf("%*s    %smaxDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDescriptorSets));
+    printf("%*s    %smaxViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxViewports));
+    printf("%*s    %smaxColorAttachments = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxColorAttachments));
+}
+
+// Output all struct elements, each on their own line
+void xgl_physical_gpu_properties_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_physical_gpu_properties_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_image_view_attach_info_struct_wrapper class definition
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_view_attach_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_IMAGE_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_view_attach_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+    printf("%*s    %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_view_attach_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
 // xgl_memory_alloc_buffer_info_struct_wrapper class definition
 xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
 xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -3060,251 +4423,559 @@
 }
 
 
-// xgl_compute_pipeline_create_info_struct_wrapper class definition
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_buffer_copy_struct_wrapper class definition
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_create_info_struct_wrapper() {}
+xgl_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt()
+void xgl_buffer_copy_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_COMPUTE_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_BUFFER_COPY = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_compute_pipeline_create_info_struct_wrapper::display_struct_members()
+void xgl_buffer_copy_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %scs = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.cs));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-    printf("%*s    %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
-    printf("%*s    %slocalSizeX = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeX));
-    printf("%*s    %slocalSizeY = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeY));
-    printf("%*s    %slocalSizeZ = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeZ));
+    printf("%*s    %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.srcOffset));
+    printf("%*s    %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.destOffset));
+    printf("%*s    %scopySize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.copySize));
 }
 
 // Output all struct elements, each on their own line
-void xgl_compute_pipeline_create_info_struct_wrapper::display_txt()
+void xgl_buffer_copy_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_compute_pipeline_create_info_struct_wrapper::display_full_txt()
+void xgl_buffer_copy_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    if (&m_struct.cs) {
-        xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs);
+}
+
+
+// xgl_image_memory_bind_info_struct_wrapper class definition
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_memory_bind_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_IMAGE_MEMORY_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_memory_bind_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresource));
+    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
+    printf("%*s    %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_memory_bind_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_memory_bind_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.extent) {
+        xgl_extent3d_struct_wrapper class0(&m_struct.extent);
         class0.set_indent(m_indent + 4);
         class0.display_full_txt();
     }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    if (&m_struct.offset) {
+        xgl_offset3d_struct_wrapper class1(&m_struct.offset);
+        class1.set_indent(m_indent + 4);
+        class1.display_full_txt();
+    }
+    if (&m_struct.subresource) {
+        xgl_image_subresource_struct_wrapper class2(&m_struct.subresource);
+        class2.set_indent(m_indent + 4);
+        class2.display_full_txt();
     }
 }
 
 
-// xgl_channel_mapping_struct_wrapper class definition
-xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_memory_requirements_struct_wrapper class definition
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {}
+xgl_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_channel_mapping_struct_wrapper::display_single_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CHANNEL_MAPPING = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_IMAGE_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_channel_mapping_struct_wrapper::display_struct_members()
+void xgl_image_memory_requirements_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %sr = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.r));
-    printf("%*s    %sg = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.g));
-    printf("%*s    %sb = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.b));
-    printf("%*s    %sa = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.a));
+    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+    printf("%*s    %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
+    printf("%*s    %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
 }
 
 // Output all struct elements, each on their own line
-void xgl_channel_mapping_struct_wrapper::display_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_channel_mapping_struct_wrapper::display_full_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 
-// xgl_peer_image_open_info_struct_wrapper class definition
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_shader_struct_wrapper class definition
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
+xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_shader_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PEER_IMAGE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PIPELINE_SHADER = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_peer_image_open_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_shader_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage));
-}
-
-// Output all struct elements, each on their own line
-void xgl_peer_image_open_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_peer_image_open_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_dynamic_vp_state_create_info_struct_wrapper class definition
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dynamic_vp_state_create_info_struct_wrapper::~xgl_dynamic_vp_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DYNAMIC_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sviewportAndScissorCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.viewportAndScissorCount));
+    printf("%*s    %sstage = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PIPELINE_SHADER_STAGE(m_struct.stage));
+    printf("%*s    %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.shader));
+    printf("%*s    %slinkConstBufferCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linkConstBufferCount));
     uint32_t i;
-    for (i = 0; i<viewportAndScissorCount; i++) {
-        printf("%*s    %spViewports[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pViewports)[i]);
-    }
-    for (i = 0; i<viewportAndScissorCount; i++) {
-        printf("%*s    %spScissors[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pScissors)[i]);
+    for (i = 0; i<linkConstBufferCount; i++) {
+        printf("%*s    %spLinkConstBufferInfo[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pLinkConstBufferInfo)[i]);
     }
 }
 
 // Output all struct elements, each on their own line
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_shader_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_shader_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
     uint32_t i;
-    for (i = 0; i<viewportAndScissorCount; i++) {
-            xgl_rect_struct_wrapper class0(&(m_struct.pScissors[i]));
+    for (i = 0; i<linkConstBufferCount; i++) {
+            xgl_link_const_buffer_struct_wrapper class0(&(m_struct.pLinkConstBufferInfo[i]));
             class0.set_indent(m_indent + 4);
             class0.display_full_txt();
     }
-    for (i = 0; i<viewportAndScissorCount; i++) {
-            xgl_viewport_struct_wrapper class1(&(m_struct.pViewports[i]));
-            class1.set_indent(m_indent + 4);
-            class1.display_full_txt();
-    }
+}
+
+
+// xgl_offset3d_struct_wrapper class definition
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_offset3d_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_OFFSET3D = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_offset3d_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+    printf("%*s    %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
+    printf("%*s    %sz = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
+}
+
+// Output all struct elements, each on their own line
+void xgl_offset3d_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_offset3d_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_buffer_view_attach_info_struct_wrapper class definition
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_BUFFER_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_view_attach_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_view_attach_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_view_attach_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
     }
 }
 
 
-// xgl_physical_gpu_performance_struct_wrapper class definition
-xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_extent3d_struct_wrapper class definition
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
+xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_performance_struct_wrapper::display_single_txt()
+void xgl_extent3d_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_EXTENT3D = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_performance_struct_wrapper::display_struct_members()
+void xgl_extent3d_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %smaxGpuClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxGpuClock));
-    printf("%*s    %saluPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.aluPerClock));
-    printf("%*s    %stexPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.texPerClock));
-    printf("%*s    %sprimsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.primsPerClock));
-    printf("%*s    %spixelsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pixelsPerClock));
+    printf("%*s    %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+    printf("%*s    %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+    printf("%*s    %sdepth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.depth));
 }
 
 // Output all struct elements, each on their own line
-void xgl_physical_gpu_performance_struct_wrapper::display_txt()
+void xgl_extent3d_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_performance_struct_wrapper::display_full_txt()
+void xgl_extent3d_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 
+// xgl_sampler_image_view_info_struct_wrapper class definition
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_sampler_image_view_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_SAMPLER_IMAGE_VIEW_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_sampler_image_view_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %spSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pSampler));
+    printf("%*s    %spImageView = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pImageView));
+}
+
+// Output all struct elements, each on their own line
+void xgl_sampler_image_view_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_sampler_image_view_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pImageView) {
+        xgl_image_view_attach_info_struct_wrapper class0(m_struct.pImageView);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+}
+
+
+// xgl_image_subresource_struct_wrapper class definition
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_subresource_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_IMAGE_SUBRESOURCE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_subresource_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
+    printf("%*s    %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+    printf("%*s    %sarraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySlice));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_subresource_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_subresource_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+
+// xgl_layer_create_info_struct_wrapper class definition
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_layer_create_info_struct_wrapper::~xgl_layer_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_layer_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_LAYER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_layer_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %slayerCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layerCount));
+    uint32_t i;
+    for (i = 0; i<layerCount; i++) {
+        printf("%*s    %sppActiveLayerNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppActiveLayerNames)[0]);
+    }
+}
+
+// Output all struct elements, each on their own line
+void xgl_layer_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_layer_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_pipeline_vp_state_create_info_struct_wrapper class definition
+xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_pipeline_vp_state_create_info_struct_wrapper::~xgl_pipeline_vp_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_PIPELINE_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %snumViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.numViewports));
+    printf("%*s    %sclipOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.clipOrigin));
+    printf("%*s    %sdepthMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DEPTH_MODE(m_struct.depthMode));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// xgl_buffer_create_info_struct_wrapper class definition
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+    m_struct = *pInStruct;
+    m_origStructAddr = pInStruct;
+}
+xgl_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_create_info_struct_wrapper::display_single_txt()
+{
+    printf(" %*sXGL_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_create_info_struct_wrapper::display_struct_members()
+{
+    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+    printf("%*s    %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
 // xgl_render_pass_create_info_struct_wrapper class definition
 xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
 xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper(XGL_RENDER_PASS_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -3379,785 +5050,48 @@
 }
 
 
-// xgl_viewport_struct_wrapper class definition
-xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_descriptor_set_layout_create_info_struct_wrapper class definition
+xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_viewport_struct_wrapper::~xgl_viewport_struct_wrapper() {}
+xgl_descriptor_set_layout_create_info_struct_wrapper::~xgl_descriptor_set_layout_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_viewport_struct_wrapper::display_single_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_VIEWPORT = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_viewport_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %soriginX = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originX));
-    printf("%*s    %soriginY = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originY));
-    printf("%*s    %swidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
-    printf("%*s    %sheight = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
-    printf("%*s    %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
-    printf("%*s    %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
-}
-
-// Output all struct elements, each on their own line
-void xgl_viewport_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_viewport_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_dynamic_ds_state_create_info_struct_wrapper class definition
-xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dynamic_ds_state_create_info_struct_wrapper::~xgl_dynamic_ds_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DYNAMIC_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
-    printf("%*s    %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
-    printf("%*s    %sstencilReadMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilReadMask));
-    printf("%*s    %sstencilWriteMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilWriteMask));
-    printf("%*s    %sstencilFrontRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilFrontRef));
-    printf("%*s    %sstencilBackRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilBackRef));
-}
-
-// Output all struct elements, each on their own line
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_buffer_create_info_struct_wrapper class definition
-xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
-    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_cmd_buffer_graphics_begin_info_struct_wrapper class definition
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::~xgl_cmd_buffer_graphics_begin_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass));
-}
-
-// Output all struct elements, each on their own line
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_rect_struct_wrapper class definition
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(const XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_rect_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_rect_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
-    printf("%*s    %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
-}
-
-// Output all struct elements, each on their own line
-void xgl_rect_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_rect_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (&m_struct.extent) {
-        xgl_extent2d_struct_wrapper class0(&m_struct.extent);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    if (&m_struct.offset) {
-        xgl_offset2d_struct_wrapper class1(&m_struct.offset);
-        class1.set_indent(m_indent + 4);
-        class1.display_full_txt();
-    }
-}
-
-
-// xgl_buffer_memory_barrier_struct_wrapper class definition
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_memory_barrier_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
-    printf("%*s    %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
-    printf("%*s    %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
-    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
-    printf("%*s    %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_memory_barrier_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_pipeline_ds_state_create_info_struct_wrapper class definition
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_ds_state_create_info_struct_wrapper::~xgl_pipeline_ds_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
-    printf("%*s    %sdepthTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthTestEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %sdepthWriteEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthWriteEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %sdepthFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.depthFunc));
-    printf("%*s    %sdepthBoundsEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBoundsEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %sstencilTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilTestEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %sfront = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.front));
-    printf("%*s    %sback = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.back));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (&m_struct.back) {
-        xgl_stencil_op_state_struct_wrapper class0(&m_struct.back);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    if (&m_struct.front) {
-        xgl_stencil_op_state_struct_wrapper class1(&m_struct.front);
-        class1.set_indent(m_indent + 4);
-        class1.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_descriptor_type_count_struct_wrapper class definition
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_descriptor_type_count_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DESCRIPTOR_TYPE_COUNT = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_descriptor_type_count_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %stype = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.type));
-    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
-}
-
-// Output all struct elements, each on their own line
-void xgl_descriptor_type_count_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_type_count_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_update_sampler_textures_struct_wrapper class definition
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_update_sampler_textures_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_update_sampler_textures_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
-    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-        printf("%*s    %spSamplerImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pSamplerImageViews)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_update_sampler_textures_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_sampler_textures_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-            xgl_sampler_image_view_info_struct_wrapper class0(&(m_struct.pSamplerImageViews[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_query_pool_create_info_struct_wrapper class definition
-xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_query_pool_create_info_struct_wrapper::~xgl_query_pool_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_QUERY_POOL_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_query_pool_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %squeryType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUERY_TYPE(m_struct.queryType));
-    printf("%*s    %sslots = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slots));
-}
-
-// Output all struct elements, each on their own line
-void xgl_query_pool_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_query_pool_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_event_create_info_struct_wrapper class definition
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_event_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_EVENT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_event_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_event_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_event_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_offset2d_struct_wrapper class definition
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_offset2d_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_OFFSET2D = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_offset2d_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
-    printf("%*s    %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
-}
-
-// Output all struct elements, each on their own line
-void xgl_offset2d_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_offset2d_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_update_buffers_struct_wrapper class definition
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_update_buffers_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_UPDATE_BUFFERS = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_update_buffers_struct_wrapper::display_struct_members()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_struct_members()
 {
     printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
     printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
     printf("%*s    %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
-    printf("%*s    %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
     printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-        printf("%*s    %spBufferViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pBufferViews)[i]);
-    }
+    printf("%*s    %sstageFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stageFlags));
+    printf("%*s    %simmutableSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.immutableSampler));
 }
 
 // Output all struct elements, each on their own line
-void xgl_update_buffers_struct_wrapper::display_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_buffers_struct_wrapper::display_full_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-            xgl_buffer_view_attach_info_struct_wrapper class0(&(m_struct.pBufferViews[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_memory_ref_struct_wrapper class definition
-xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_ref_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_MEMORY_REF = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_ref_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %smem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.mem));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_ref_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_ref_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_buffer_view_attach_info_struct_wrapper class definition
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_BUFFER_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_view_attach_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_view_attach_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_view_attach_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_pipeline_vertex_input_create_info_struct_wrapper class definition
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::~xgl_pipeline_vertex_input_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sbindingCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bindingCount));
-    uint32_t i;
-    for (i = 0; i<bindingCount; i++) {
-        printf("%*s    %spVertexBindingDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexBindingDescriptions)[i]);
-    }
-    printf("%*s    %sattributeCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attributeCount));
-    for (i = 0; i<attributeCount; i++) {
-        printf("%*s    %spVertexAttributeDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexAttributeDescriptions)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<attributeCount; i++) {
-            xgl_vertex_input_attribute_description_struct_wrapper class0(&(m_struct.pVertexAttributeDescriptions[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-    for (i = 0; i<bindingCount; i++) {
-            xgl_vertex_input_binding_description_struct_wrapper class1(&(m_struct.pVertexBindingDescriptions[i]));
-            class1.set_indent(m_indent + 4);
-            class1.display_full_txt();
-    }
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
     }
@@ -4204,46 +5138,47 @@
 }
 
 
-// xgl_shader_create_info_struct_wrapper class definition
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_memory_alloc_info_struct_wrapper class definition
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
+xgl_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_shader_create_info_struct_wrapper::display_single_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_SHADER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_shader_create_info_struct_wrapper::display_struct_members()
+void xgl_memory_alloc_info_struct_wrapper::display_struct_members()
 {
     printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
     printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %scodeSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.codeSize));
-    printf("%*s    %spCode = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pCode));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+    printf("%*s    %sallocationSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.allocationSize));
+    printf("%*s    %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
+    printf("%*s    %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
+    printf("%*s    %smemPriority = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_PRIORITY(m_struct.memPriority));
 }
 
 // Output all struct elements, each on their own line
-void xgl_shader_create_info_struct_wrapper::display_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_shader_create_info_struct_wrapper::display_full_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -4251,981 +5186,46 @@
 }
 
 
-// xgl_offset3d_struct_wrapper class definition
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_physical_gpu_queue_properties_struct_wrapper class definition
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
+xgl_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_offset3d_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_OFFSET3D = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_offset3d_struct_wrapper::display_struct_members()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
-    printf("%*s    %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
-    printf("%*s    %sz = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
-}
-
-// Output all struct elements, each on their own line
-void xgl_offset3d_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_offset3d_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_layer_create_info_struct_wrapper class definition
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_layer_create_info_struct_wrapper::~xgl_layer_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_layer_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_LAYER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_layer_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %slayerCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layerCount));
-    uint32_t i;
-    for (i = 0; i<layerCount; i++) {
-        printf("%*s    %sppActiveLayerNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppActiveLayerNames)[0]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_layer_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_layer_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_depth_stencil_view_create_info_struct_wrapper class definition
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
-    printf("%*s    %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
-    printf("%*s    %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
-    printf("%*s    %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
-    printf("%*s    %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
-    printf("%*s    %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (&m_struct.msaaResolveSubResource) {
-        xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_depth_stencil_bind_info_struct_wrapper class definition
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DEPTH_STENCIL_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_depth_stencil_bind_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
-    printf("%*s    %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
-}
-
-// Output all struct elements, each on their own line
-void xgl_depth_stencil_bind_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_depth_stencil_bind_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_image_memory_requirements_struct_wrapper class definition
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_memory_requirements_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_IMAGE_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_memory_requirements_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
-    printf("%*s    %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
-    printf("%*s    %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_memory_requirements_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_memory_requirements_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_image_subresource_range_struct_wrapper class definition
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_subresource_range_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_subresource_range_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
-    printf("%*s    %sbaseMipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseMipLevel));
-    printf("%*s    %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
-    printf("%*s    %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
-    printf("%*s    %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_subresource_range_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_subresource_range_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_update_images_struct_wrapper class definition
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_update_images_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_UPDATE_IMAGES = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_update_images_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
-    printf("%*s    %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
-    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-        printf("%*s    %spImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pImageViews)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_update_images_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_images_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-            xgl_image_view_attach_info_struct_wrapper class0(&(m_struct.pImageViews[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_dispatch_indirect_cmd_struct_wrapper class definition
-xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sx = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
-    printf("%*s    %sy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
-    printf("%*s    %sz = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
-}
-
-// Output all struct elements, each on their own line
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_extent3d_struct_wrapper class definition
-xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_extent3d_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_EXTENT3D = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_extent3d_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
-    printf("%*s    %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
-    printf("%*s    %sdepth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.depth));
-}
-
-// Output all struct elements, each on their own line
-void xgl_extent3d_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_extent3d_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_clear_color_value_struct_wrapper class definition
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_clear_color_value_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_CLEAR_COLOR_VALUE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_clear_color_value_struct_wrapper::display_struct_members()
-{
-    uint32_t i;
-    for (i = 0; i<4; i++) {
-        printf("%*s    %sfloatColor[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.floatColor)[i]);
-    }
-    for (i = 0; i<4; i++) {
-        printf("%*s    %srawColor[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.rawColor)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_clear_color_value_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_clear_color_value_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_memory_alloc_image_info_struct_wrapper class definition
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_memory_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_MEMORY_ALLOC_IMAGE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_alloc_image_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
-    printf("%*s    %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
-    printf("%*s    %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_alloc_image_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_device_queue_create_info_struct_wrapper class definition
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_DEVICE_QUEUE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_device_queue_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %squeueNodeIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueNodeIndex));
+    printf("%*s    %squeueFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueFlags));
     printf("%*s    %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
+    printf("%*s    %smaxAtomicCounters = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAtomicCounters));
+    printf("%*s    %ssupportsTimestamps = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsTimestamps) ? "TRUE" : "FALSE");
 }
 
 // Output all struct elements, each on their own line
-void xgl_device_queue_create_info_struct_wrapper::display_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 // Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_device_queue_create_info_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
-
-// xgl_stencil_op_state_struct_wrapper class definition
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_stencil_op_state_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_STENCIL_OP_STATE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_stencil_op_state_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sstencilFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilFailOp));
-    printf("%*s    %sstencilPassOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilPassOp));
-    printf("%*s    %sstencilDepthFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilDepthFailOp));
-    printf("%*s    %sstencilFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.stencilFunc));
-}
-
-// Output all struct elements, each on their own line
-void xgl_stencil_op_state_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_stencil_op_state_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_pipeline_shader_struct_wrapper class definition
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_shader_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_SHADER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_shader_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sstage = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PIPELINE_SHADER_STAGE(m_struct.stage));
-    printf("%*s    %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.shader));
-    printf("%*s    %slinkConstBufferCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linkConstBufferCount));
-    uint32_t i;
-    for (i = 0; i<linkConstBufferCount; i++) {
-        printf("%*s    %spLinkConstBufferInfo[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pLinkConstBufferInfo)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_shader_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_shader_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<linkConstBufferCount; i++) {
-            xgl_link_const_buffer_struct_wrapper class0(&(m_struct.pLinkConstBufferInfo[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-}
-
-
-// xgl_queue_semaphore_create_info_struct_wrapper class definition
-xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_QUEUE_SEMAPHORE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_queue_semaphore_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sinitialCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.initialCount));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_queue_semaphore_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_pipeline_statistics_data_struct_wrapper class definition
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_statistics_data_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sfsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.fsInvocations));
-    printf("%*s    %scPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cPrimitives));
-    printf("%*s    %scInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cInvocations));
-    printf("%*s    %svsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.vsInvocations));
-    printf("%*s    %sgsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsInvocations));
-    printf("%*s    %sgsPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsPrimitives));
-    printf("%*s    %siaPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaPrimitives));
-    printf("%*s    %siaVertices = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaVertices));
-    printf("%*s    %stcsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tcsInvocations));
-    printf("%*s    %stesInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tesInvocations));
-    printf("%*s    %scsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.csInvocations));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_statistics_data_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_vertex_input_attribute_description_struct_wrapper class definition
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_vertex_input_attribute_description_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_vertex_input_attribute_description_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sbinding = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.binding));
-    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
-    printf("%*s    %soffsetInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offsetInBytes));
-}
-
-// Output all struct elements, each on their own line
-void xgl_vertex_input_attribute_description_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_vertex_input_attribute_description_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_vertex_input_binding_description_struct_wrapper class definition
-xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_vertex_input_binding_description_struct_wrapper::~xgl_vertex_input_binding_description_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_vertex_input_binding_description_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_vertex_input_binding_description_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %sstrideInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.strideInBytes));
-    printf("%*s    %sstepRate = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VERTEX_INPUT_STEP_RATE(m_struct.stepRate));
-}
-
-// Output all struct elements, each on their own line
-void xgl_vertex_input_binding_description_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_vertex_input_binding_description_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-
-// xgl_update_samplers_struct_wrapper class definition
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_update_samplers_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_UPDATE_SAMPLERS = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_update_samplers_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
-    printf("%*s    %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
-    uint32_t i;
-    for (i = 0; i<count; i++) {
-        printf("%*s    %spSamplers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pSamplers)[i]);
-    }
-}
-
-// Output all struct elements, each on their own line
-void xgl_update_samplers_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_samplers_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_image_create_info_struct_wrapper class definition
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %simageType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TYPE(m_struct.imageType));
-    printf("%*s    %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
-    printf("%*s    %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
-    printf("%*s    %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
-    printf("%*s    %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
-    printf("%*s    %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
-    printf("%*s    %stiling = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TILING(m_struct.tiling));
-    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
-    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (&m_struct.extent) {
-        xgl_extent3d_struct_wrapper class0(&m_struct.extent);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
-
-// xgl_pipeline_tess_state_create_info_struct_wrapper class definition
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_struct_members()
-{
-    printf("%*s    %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
-    printf("%*s    %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
-    printf("%*s    %spatchControlPoints = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.patchControlPoints));
-    printf("%*s    %soptimalTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTessFactor));
-    printf("%*s    %sfixedTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.fixedTessFactor));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
-}
-
 //any footer info for class
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h
index 3439d04..ac2fe0c 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h
@@ -7,80 +7,14 @@
 #include <stdlib.h>
 
 //class declaration
-class xgl_format_properties_struct_wrapper
+class xgl_pipeline_ia_state_create_info_struct_wrapper
 {
 public:
-    xgl_format_properties_struct_wrapper();
-    xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct);
-    xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct);
+    xgl_pipeline_ia_state_create_info_struct_wrapper();
+    xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
+    xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
 
-    virtual ~xgl_format_properties_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_FLAGS get_linearTilingFeatures() { return m_struct.linearTilingFeatures; }
-    void set_linearTilingFeatures(XGL_FLAGS inValue) { m_struct.linearTilingFeatures = inValue; }
-    XGL_FLAGS get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; }
-    void set_optimalTilingFeatures(XGL_FLAGS inValue) { m_struct.optimalTilingFeatures = inValue; }
-
-
-private:
-    XGL_FORMAT_PROPERTIES m_struct;
-    const XGL_FORMAT_PROPERTIES* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_image_copy_struct_wrapper
-{
-public:
-    xgl_buffer_image_copy_struct_wrapper();
-    xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct);
-    xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct);
-
-    virtual ~xgl_buffer_image_copy_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_GPU_SIZE get_bufferOffset() { return m_struct.bufferOffset; }
-    void set_bufferOffset(XGL_GPU_SIZE inValue) { m_struct.bufferOffset = inValue; }
-    XGL_IMAGE_SUBRESOURCE get_imageSubresource() { return m_struct.imageSubresource; }
-    void set_imageSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.imageSubresource = inValue; }
-    XGL_OFFSET3D get_imageOffset() { return m_struct.imageOffset; }
-    void set_imageOffset(XGL_OFFSET3D inValue) { m_struct.imageOffset = inValue; }
-    XGL_EXTENT3D get_imageExtent() { return m_struct.imageExtent; }
-    void set_imageExtent(XGL_EXTENT3D inValue) { m_struct.imageExtent = inValue; }
-
-
-private:
-    XGL_BUFFER_IMAGE_COPY m_struct;
-    const XGL_BUFFER_IMAGE_COPY* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_peer_memory_open_info_struct_wrapper
-{
-public:
-    xgl_peer_memory_open_info_struct_wrapper();
-    xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
-    xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
-
-    virtual ~xgl_peer_memory_open_info_struct_wrapper();
+    virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -90,13 +24,399 @@
     XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
     void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
     const void* get_pNext() { return m_struct.pNext; }
-    XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; }
-    void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; }
+    XGL_PRIMITIVE_TOPOLOGY get_topology() { return m_struct.topology; }
+    void set_topology(XGL_PRIMITIVE_TOPOLOGY inValue) { m_struct.topology = inValue; }
+    bool32_t get_disableVertexReuse() { return m_struct.disableVertexReuse; }
+    void set_disableVertexReuse(bool32_t inValue) { m_struct.disableVertexReuse = inValue; }
+    bool32_t get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; }
+    void set_primitiveRestartEnable(bool32_t inValue) { m_struct.primitiveRestartEnable = inValue; }
+    uint32_t get_primitiveRestartIndex() { return m_struct.primitiveRestartIndex; }
+    void set_primitiveRestartIndex(uint32_t inValue) { m_struct.primitiveRestartIndex = inValue; }
 
 
 private:
-    XGL_PEER_MEMORY_OPEN_INFO m_struct;
-    const XGL_PEER_MEMORY_OPEN_INFO* m_origStructAddr;
+    XGL_PIPELINE_IA_STATE_CREATE_INFO m_struct;
+    const XGL_PIPELINE_IA_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_application_info_struct_wrapper
+{
+public:
+    xgl_application_info_struct_wrapper();
+    xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct);
+    xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct);
+
+    virtual ~xgl_application_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    const char* get_pAppName() { return m_struct.pAppName; }
+    uint32_t get_appVersion() { return m_struct.appVersion; }
+    void set_appVersion(uint32_t inValue) { m_struct.appVersion = inValue; }
+    const char* get_pEngineName() { return m_struct.pEngineName; }
+    uint32_t get_engineVersion() { return m_struct.engineVersion; }
+    void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; }
+    uint32_t get_apiVersion() { return m_struct.apiVersion; }
+    void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
+
+
+private:
+    XGL_APPLICATION_INFO m_struct;
+    const XGL_APPLICATION_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_link_const_buffer_struct_wrapper
+{
+public:
+    xgl_link_const_buffer_struct_wrapper();
+    xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct);
+    xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct);
+
+    virtual ~xgl_link_const_buffer_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    uint32_t get_bufferId() { return m_struct.bufferId; }
+    void set_bufferId(uint32_t inValue) { m_struct.bufferId = inValue; }
+    size_t get_bufferSize() { return m_struct.bufferSize; }
+    void set_bufferSize(size_t inValue) { m_struct.bufferSize = inValue; }
+    const void* get_pBufferData() { return m_struct.pBufferData; }
+
+
+private:
+    XGL_LINK_CONST_BUFFER m_struct;
+    const XGL_LINK_CONST_BUFFER* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_samplers_struct_wrapper
+{
+public:
+    xgl_update_samplers_struct_wrapper();
+    xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct);
+    xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct);
+
+    virtual ~xgl_update_samplers_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_index() { return m_struct.index; }
+    void set_index(uint32_t inValue) { m_struct.index = inValue; }
+    uint32_t get_count() { return m_struct.count; }
+    void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+    XGL_UPDATE_SAMPLERS m_struct;
+    const XGL_UPDATE_SAMPLERS* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_stencil_op_state_struct_wrapper
+{
+public:
+    xgl_stencil_op_state_struct_wrapper();
+    xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct);
+    xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct);
+
+    virtual ~xgl_stencil_op_state_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STENCIL_OP get_stencilFailOp() { return m_struct.stencilFailOp; }
+    void set_stencilFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilFailOp = inValue; }
+    XGL_STENCIL_OP get_stencilPassOp() { return m_struct.stencilPassOp; }
+    void set_stencilPassOp(XGL_STENCIL_OP inValue) { m_struct.stencilPassOp = inValue; }
+    XGL_STENCIL_OP get_stencilDepthFailOp() { return m_struct.stencilDepthFailOp; }
+    void set_stencilDepthFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilDepthFailOp = inValue; }
+    XGL_COMPARE_FUNC get_stencilFunc() { return m_struct.stencilFunc; }
+    void set_stencilFunc(XGL_COMPARE_FUNC inValue) { m_struct.stencilFunc = inValue; }
+
+
+private:
+    XGL_STENCIL_OP_STATE m_struct;
+    const XGL_STENCIL_OP_STATE* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_peer_image_open_info_struct_wrapper
+{
+public:
+    xgl_peer_image_open_info_struct_wrapper();
+    xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
+    xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
+
+    virtual ~xgl_peer_image_open_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_IMAGE get_originalImage() { return m_struct.originalImage; }
+    void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; }
+
+
+private:
+    XGL_PEER_IMAGE_OPEN_INFO m_struct;
+    const XGL_PEER_IMAGE_OPEN_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_device_create_info_struct_wrapper
+{
+public:
+    xgl_device_create_info_struct_wrapper();
+    xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct);
+    xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_device_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_queueRecordCount() { return m_struct.queueRecordCount; }
+    void set_queueRecordCount(uint32_t inValue) { m_struct.queueRecordCount = inValue; }
+    uint32_t get_extensionCount() { return m_struct.extensionCount; }
+    void set_extensionCount(uint32_t inValue) { m_struct.extensionCount = inValue; }
+    XGL_VALIDATION_LEVEL get_maxValidationLevel() { return m_struct.maxValidationLevel; }
+    void set_maxValidationLevel(XGL_VALIDATION_LEVEL inValue) { m_struct.maxValidationLevel = inValue; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_DEVICE_CREATE_INFO m_struct;
+    const XGL_DEVICE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_buffer_memory_requirements_struct_wrapper
+{
+public:
+    xgl_buffer_memory_requirements_struct_wrapper();
+    xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
+    xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
+
+    virtual ~xgl_buffer_memory_requirements_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_FLAGS get_usage() { return m_struct.usage; }
+    void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+
+
+private:
+    XGL_BUFFER_MEMORY_REQUIREMENTS m_struct;
+    const XGL_BUFFER_MEMORY_REQUIREMENTS* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_buffers_struct_wrapper
+{
+public:
+    xgl_update_buffers_struct_wrapper();
+    xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct);
+    xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct);
+
+    virtual ~xgl_update_buffers_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+    void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+    uint32_t get_index() { return m_struct.index; }
+    void set_index(uint32_t inValue) { m_struct.index = inValue; }
+    uint32_t get_count() { return m_struct.count; }
+    void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+    XGL_UPDATE_BUFFERS m_struct;
+    const XGL_UPDATE_BUFFERS* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_vertex_input_attribute_description_struct_wrapper
+{
+public:
+    xgl_vertex_input_attribute_description_struct_wrapper();
+    xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
+    xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
+
+    virtual ~xgl_vertex_input_attribute_description_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    uint32_t get_binding() { return m_struct.binding; }
+    void set_binding(uint32_t inValue) { m_struct.binding = inValue; }
+    XGL_FORMAT get_format() { return m_struct.format; }
+    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+    uint32_t get_offsetInBytes() { return m_struct.offsetInBytes; }
+    void set_offsetInBytes(uint32_t inValue) { m_struct.offsetInBytes = inValue; }
+
+
+private:
+    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION m_struct;
+    const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_vertex_input_create_info_struct_wrapper
+{
+public:
+    xgl_pipeline_vertex_input_create_info_struct_wrapper();
+    xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
+    xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_pipeline_vertex_input_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_bindingCount() { return m_struct.bindingCount; }
+    void set_bindingCount(uint32_t inValue) { m_struct.bindingCount = inValue; }
+    uint32_t get_attributeCount() { return m_struct.attributeCount; }
+    void set_attributeCount(uint32_t inValue) { m_struct.attributeCount = inValue; }
+
+
+private:
+    XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_struct;
+    const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_rs_state_create_info_struct_wrapper
+{
+public:
+    xgl_dynamic_rs_state_create_info_struct_wrapper();
+    xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
+    xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_dynamic_rs_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    float get_depthBias() { return m_struct.depthBias; }
+    void set_depthBias(float inValue) { m_struct.depthBias = inValue; }
+    float get_depthBiasClamp() { return m_struct.depthBiasClamp; }
+    void set_depthBiasClamp(float inValue) { m_struct.depthBiasClamp = inValue; }
+    float get_slopeScaledDepthBias() { return m_struct.slopeScaledDepthBias; }
+    void set_slopeScaledDepthBias(float inValue) { m_struct.slopeScaledDepthBias = inValue; }
+    float get_pointSize() { return m_struct.pointSize; }
+    void set_pointSize(float inValue) { m_struct.pointSize = inValue; }
+    float get_pointFadeThreshold() { return m_struct.pointFadeThreshold; }
+    void set_pointFadeThreshold(float inValue) { m_struct.pointFadeThreshold = inValue; }
+    float get_lineWidth() { return m_struct.lineWidth; }
+    void set_lineWidth(float inValue) { m_struct.lineWidth = inValue; }
+
+
+private:
+    XGL_DYNAMIC_RS_STATE_CREATE_INFO m_struct;
+    const XGL_DYNAMIC_RS_STATE_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -140,33 +460,2226 @@
 
 
 //class declaration
-class xgl_physical_gpu_queue_properties_struct_wrapper
+class xgl_draw_indexed_indirect_cmd_struct_wrapper
 {
 public:
-    xgl_physical_gpu_queue_properties_struct_wrapper();
-    xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
-    xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
+    xgl_draw_indexed_indirect_cmd_struct_wrapper();
+    xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
+    xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
 
-    virtual ~xgl_physical_gpu_queue_properties_struct_wrapper();
+    virtual ~xgl_draw_indexed_indirect_cmd_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
     void display_full_txt();
 
     void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_FLAGS get_queueFlags() { return m_struct.queueFlags; }
-    void set_queueFlags(XGL_FLAGS inValue) { m_struct.queueFlags = inValue; }
-    uint32_t get_queueCount() { return m_struct.queueCount; }
-    void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
-    uint32_t get_maxAtomicCounters() { return m_struct.maxAtomicCounters; }
-    void set_maxAtomicCounters(uint32_t inValue) { m_struct.maxAtomicCounters = inValue; }
-    bool32_t get_supportsTimestamps() { return m_struct.supportsTimestamps; }
-    void set_supportsTimestamps(bool32_t inValue) { m_struct.supportsTimestamps = inValue; }
+    uint32_t get_indexCount() { return m_struct.indexCount; }
+    void set_indexCount(uint32_t inValue) { m_struct.indexCount = inValue; }
+    uint32_t get_instanceCount() { return m_struct.instanceCount; }
+    void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
+    uint32_t get_firstIndex() { return m_struct.firstIndex; }
+    void set_firstIndex(uint32_t inValue) { m_struct.firstIndex = inValue; }
+    int32_t get_vertexOffset() { return m_struct.vertexOffset; }
+    void set_vertexOffset(int32_t inValue) { m_struct.vertexOffset = inValue; }
+    uint32_t get_firstInstance() { return m_struct.firstInstance; }
+    void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
 
 
 private:
-    XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct;
-    const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr;
+    XGL_DRAW_INDEXED_INDIRECT_CMD m_struct;
+    const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_vp_state_create_info_struct_wrapper
+{
+public:
+    xgl_dynamic_vp_state_create_info_struct_wrapper();
+    xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
+    xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_dynamic_vp_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_viewportAndScissorCount() { return m_struct.viewportAndScissorCount; }
+    void set_viewportAndScissorCount(uint32_t inValue) { m_struct.viewportAndScissorCount = inValue; }
+
+
+private:
+    XGL_DYNAMIC_VP_STATE_CREATE_INFO m_struct;
+    const XGL_DYNAMIC_VP_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_shader_create_info_struct_wrapper
+{
+public:
+    xgl_shader_create_info_struct_wrapper();
+    xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct);
+    xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_shader_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    size_t get_codeSize() { return m_struct.codeSize; }
+    void set_codeSize(size_t inValue) { m_struct.codeSize = inValue; }
+    const void* get_pCode() { return m_struct.pCode; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_SHADER_CREATE_INFO m_struct;
+    const XGL_SHADER_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_ref_struct_wrapper
+{
+public:
+    xgl_memory_ref_struct_wrapper();
+    xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct);
+    xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct);
+
+    virtual ~xgl_memory_ref_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
+    void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_MEMORY_REF m_struct;
+    const XGL_MEMORY_REF* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_format_properties_struct_wrapper
+{
+public:
+    xgl_format_properties_struct_wrapper();
+    xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct);
+    xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct);
+
+    virtual ~xgl_format_properties_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_FLAGS get_linearTilingFeatures() { return m_struct.linearTilingFeatures; }
+    void set_linearTilingFeatures(XGL_FLAGS inValue) { m_struct.linearTilingFeatures = inValue; }
+    XGL_FLAGS get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; }
+    void set_optimalTilingFeatures(XGL_FLAGS inValue) { m_struct.optimalTilingFeatures = inValue; }
+
+
+private:
+    XGL_FORMAT_PROPERTIES m_struct;
+    const XGL_FORMAT_PROPERTIES* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_statistics_data_struct_wrapper
+{
+public:
+    xgl_pipeline_statistics_data_struct_wrapper();
+    xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct);
+    xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct);
+
+    virtual ~xgl_pipeline_statistics_data_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    uint64_t get_fsInvocations() { return m_struct.fsInvocations; }
+    void set_fsInvocations(uint64_t inValue) { m_struct.fsInvocations = inValue; }
+    uint64_t get_cPrimitives() { return m_struct.cPrimitives; }
+    void set_cPrimitives(uint64_t inValue) { m_struct.cPrimitives = inValue; }
+    uint64_t get_cInvocations() { return m_struct.cInvocations; }
+    void set_cInvocations(uint64_t inValue) { m_struct.cInvocations = inValue; }
+    uint64_t get_vsInvocations() { return m_struct.vsInvocations; }
+    void set_vsInvocations(uint64_t inValue) { m_struct.vsInvocations = inValue; }
+    uint64_t get_gsInvocations() { return m_struct.gsInvocations; }
+    void set_gsInvocations(uint64_t inValue) { m_struct.gsInvocations = inValue; }
+    uint64_t get_gsPrimitives() { return m_struct.gsPrimitives; }
+    void set_gsPrimitives(uint64_t inValue) { m_struct.gsPrimitives = inValue; }
+    uint64_t get_iaPrimitives() { return m_struct.iaPrimitives; }
+    void set_iaPrimitives(uint64_t inValue) { m_struct.iaPrimitives = inValue; }
+    uint64_t get_iaVertices() { return m_struct.iaVertices; }
+    void set_iaVertices(uint64_t inValue) { m_struct.iaVertices = inValue; }
+    uint64_t get_tcsInvocations() { return m_struct.tcsInvocations; }
+    void set_tcsInvocations(uint64_t inValue) { m_struct.tcsInvocations = inValue; }
+    uint64_t get_tesInvocations() { return m_struct.tesInvocations; }
+    void set_tesInvocations(uint64_t inValue) { m_struct.tesInvocations = inValue; }
+    uint64_t get_csInvocations() { return m_struct.csInvocations; }
+    void set_csInvocations(uint64_t inValue) { m_struct.csInvocations = inValue; }
+
+
+private:
+    XGL_PIPELINE_STATISTICS_DATA m_struct;
+    const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_alloc_callbacks_struct_wrapper
+{
+public:
+    xgl_alloc_callbacks_struct_wrapper();
+    xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct);
+    xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct);
+
+    virtual ~xgl_alloc_callbacks_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    void* get_pUserData() { return m_struct.pUserData; }
+    void set_pUserData(void* inValue) { m_struct.pUserData = inValue; }
+    XGL_ALLOC_FUNCTION get_pfnAlloc() { return m_struct.pfnAlloc; }
+    void set_pfnAlloc(XGL_ALLOC_FUNCTION inValue) { m_struct.pfnAlloc = inValue; }
+    XGL_FREE_FUNCTION get_pfnFree() { return m_struct.pfnFree; }
+    void set_pfnFree(XGL_FREE_FUNCTION inValue) { m_struct.pfnFree = inValue; }
+
+
+private:
+    XGL_ALLOC_CALLBACKS m_struct;
+    const XGL_ALLOC_CALLBACKS* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_cb_state_create_info_struct_wrapper
+{
+public:
+    xgl_pipeline_cb_state_create_info_struct_wrapper();
+    xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
+    xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    bool32_t get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; }
+    void set_alphaToCoverageEnable(bool32_t inValue) { m_struct.alphaToCoverageEnable = inValue; }
+    bool32_t get_logicOpEnable() { return m_struct.logicOpEnable; }
+    void set_logicOpEnable(bool32_t inValue) { m_struct.logicOpEnable = inValue; }
+    XGL_LOGIC_OP get_logicOp() { return m_struct.logicOp; }
+    void set_logicOp(XGL_LOGIC_OP inValue) { m_struct.logicOp = inValue; }
+    uint32_t get_attachmentCount() { return m_struct.attachmentCount; }
+    void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; }
+
+
+private:
+    XGL_PIPELINE_CB_STATE_CREATE_INFO m_struct;
+    const XGL_PIPELINE_CB_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_draw_indirect_cmd_struct_wrapper
+{
+public:
+    xgl_draw_indirect_cmd_struct_wrapper();
+    xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct);
+    xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct);
+
+    virtual ~xgl_draw_indirect_cmd_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    uint32_t get_vertexCount() { return m_struct.vertexCount; }
+    void set_vertexCount(uint32_t inValue) { m_struct.vertexCount = inValue; }
+    uint32_t get_instanceCount() { return m_struct.instanceCount; }
+    void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
+    uint32_t get_firstVertex() { return m_struct.firstVertex; }
+    void set_firstVertex(uint32_t inValue) { m_struct.firstVertex = inValue; }
+    uint32_t get_firstInstance() { return m_struct.firstInstance; }
+    void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
+
+
+private:
+    XGL_DRAW_INDIRECT_CMD m_struct;
+    const XGL_DRAW_INDIRECT_CMD* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_color_attachment_view_create_info_struct_wrapper
+{
+public:
+    xgl_color_attachment_view_create_info_struct_wrapper();
+    xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
+    xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_color_attachment_view_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_IMAGE get_image() { return m_struct.image; }
+    void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+    XGL_FORMAT get_format() { return m_struct.format; }
+    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+    uint32_t get_mipLevel() { return m_struct.mipLevel; }
+    void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
+    uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+    void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+    uint32_t get_arraySize() { return m_struct.arraySize; }
+    void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+    XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
+    void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
+    XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
+    void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
+
+
+private:
+    XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct;
+    const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_cb_attachment_state_struct_wrapper
+{
+public:
+    xgl_pipeline_cb_attachment_state_struct_wrapper();
+    xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
+    xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
+
+    virtual ~xgl_pipeline_cb_attachment_state_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    bool32_t get_blendEnable() { return m_struct.blendEnable; }
+    void set_blendEnable(bool32_t inValue) { m_struct.blendEnable = inValue; }
+    XGL_FORMAT get_format() { return m_struct.format; }
+    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+    XGL_BLEND get_srcBlendColor() { return m_struct.srcBlendColor; }
+    void set_srcBlendColor(XGL_BLEND inValue) { m_struct.srcBlendColor = inValue; }
+    XGL_BLEND get_destBlendColor() { return m_struct.destBlendColor; }
+    void set_destBlendColor(XGL_BLEND inValue) { m_struct.destBlendColor = inValue; }
+    XGL_BLEND_FUNC get_blendFuncColor() { return m_struct.blendFuncColor; }
+    void set_blendFuncColor(XGL_BLEND_FUNC inValue) { m_struct.blendFuncColor = inValue; }
+    XGL_BLEND get_srcBlendAlpha() { return m_struct.srcBlendAlpha; }
+    void set_srcBlendAlpha(XGL_BLEND inValue) { m_struct.srcBlendAlpha = inValue; }
+    XGL_BLEND get_destBlendAlpha() { return m_struct.destBlendAlpha; }
+    void set_destBlendAlpha(XGL_BLEND inValue) { m_struct.destBlendAlpha = inValue; }
+    XGL_BLEND_FUNC get_blendFuncAlpha() { return m_struct.blendFuncAlpha; }
+    void set_blendFuncAlpha(XGL_BLEND_FUNC inValue) { m_struct.blendFuncAlpha = inValue; }
+    uint8_t get_channelWriteMask() { return m_struct.channelWriteMask; }
+    void set_channelWriteMask(uint8_t inValue) { m_struct.channelWriteMask = inValue; }
+
+
+private:
+    XGL_PIPELINE_CB_ATTACHMENT_STATE m_struct;
+    const XGL_PIPELINE_CB_ATTACHMENT_STATE* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_vertex_input_binding_description_struct_wrapper
+{
+public:
+    xgl_vertex_input_binding_description_struct_wrapper();
+    xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
+    xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
+
+    virtual ~xgl_vertex_input_binding_description_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    uint32_t get_strideInBytes() { return m_struct.strideInBytes; }
+    void set_strideInBytes(uint32_t inValue) { m_struct.strideInBytes = inValue; }
+    XGL_VERTEX_INPUT_STEP_RATE get_stepRate() { return m_struct.stepRate; }
+    void set_stepRate(XGL_VERTEX_INPUT_STEP_RATE inValue) { m_struct.stepRate = inValue; }
+
+
+private:
+    XGL_VERTEX_INPUT_BINDING_DESCRIPTION m_struct;
+    const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_shader_stage_create_info_struct_wrapper
+{
+public:
+    xgl_pipeline_shader_stage_create_info_struct_wrapper();
+    xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
+    xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_PIPELINE_SHADER get_shader() { return m_struct.shader; }
+    void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; }
+
+
+private:
+    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct;
+    const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_fence_create_info_struct_wrapper
+{
+public:
+    xgl_fence_create_info_struct_wrapper();
+    xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct);
+    xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_fence_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_FENCE_CREATE_INFO m_struct;
+    const XGL_FENCE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_framebuffer_create_info_struct_wrapper
+{
+public:
+    xgl_framebuffer_create_info_struct_wrapper();
+    xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
+    xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_framebuffer_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
+    void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
+    const XGL_DEPTH_STENCIL_BIND_INFO* get_pDepthStencilAttachment() { return m_struct.pDepthStencilAttachment; }
+    uint32_t get_sampleCount() { return m_struct.sampleCount; }
+    void set_sampleCount(uint32_t inValue) { m_struct.sampleCount = inValue; }
+    uint32_t get_width() { return m_struct.width; }
+    void set_width(uint32_t inValue) { m_struct.width = inValue; }
+    uint32_t get_height() { return m_struct.height; }
+    void set_height(uint32_t inValue) { m_struct.height = inValue; }
+    uint32_t get_layers() { return m_struct.layers; }
+    void set_layers(uint32_t inValue) { m_struct.layers = inValue; }
+
+
+private:
+    XGL_FRAMEBUFFER_CREATE_INFO m_struct;
+    const XGL_FRAMEBUFFER_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_extent2d_struct_wrapper
+{
+public:
+    xgl_extent2d_struct_wrapper();
+    xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct);
+    xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct);
+
+    virtual ~xgl_extent2d_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    int32_t get_width() { return m_struct.width; }
+    void set_width(int32_t inValue) { m_struct.width = inValue; }
+    int32_t get_height() { return m_struct.height; }
+    void set_height(int32_t inValue) { m_struct.height = inValue; }
+
+
+private:
+    XGL_EXTENT2D m_struct;
+    const XGL_EXTENT2D* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_compute_pipeline_create_info_struct_wrapper
+{
+public:
+    xgl_compute_pipeline_create_info_struct_wrapper();
+    xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
+    xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_compute_pipeline_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_PIPELINE_SHADER get_cs() { return m_struct.cs; }
+    void set_cs(XGL_PIPELINE_SHADER inValue) { m_struct.cs = inValue; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+    XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
+    void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
+    uint32_t get_localSizeX() { return m_struct.localSizeX; }
+    void set_localSizeX(uint32_t inValue) { m_struct.localSizeX = inValue; }
+    uint32_t get_localSizeY() { return m_struct.localSizeY; }
+    void set_localSizeY(uint32_t inValue) { m_struct.localSizeY = inValue; }
+    uint32_t get_localSizeZ() { return m_struct.localSizeZ; }
+    void set_localSizeZ(uint32_t inValue) { m_struct.localSizeZ = inValue; }
+
+
+private:
+    XGL_COMPUTE_PIPELINE_CREATE_INFO m_struct;
+    const XGL_COMPUTE_PIPELINE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_subresource_range_struct_wrapper
+{
+public:
+    xgl_image_subresource_range_struct_wrapper();
+    xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
+    xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
+
+    virtual ~xgl_image_subresource_range_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
+    void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
+    uint32_t get_baseMipLevel() { return m_struct.baseMipLevel; }
+    void set_baseMipLevel(uint32_t inValue) { m_struct.baseMipLevel = inValue; }
+    uint32_t get_mipLevels() { return m_struct.mipLevels; }
+    void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
+    uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+    void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+    uint32_t get_arraySize() { return m_struct.arraySize; }
+    void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+
+
+private:
+    XGL_IMAGE_SUBRESOURCE_RANGE m_struct;
+    const XGL_IMAGE_SUBRESOURCE_RANGE* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_tess_state_create_info_struct_wrapper
+{
+public:
+    xgl_pipeline_tess_state_create_info_struct_wrapper();
+    xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
+    xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_patchControlPoints() { return m_struct.patchControlPoints; }
+    void set_patchControlPoints(uint32_t inValue) { m_struct.patchControlPoints = inValue; }
+    float get_optimalTessFactor() { return m_struct.optimalTessFactor; }
+    void set_optimalTessFactor(float inValue) { m_struct.optimalTessFactor = inValue; }
+    float get_fixedTessFactor() { return m_struct.fixedTessFactor; }
+    void set_fixedTessFactor(float inValue) { m_struct.fixedTessFactor = inValue; }
+
+
+private:
+    XGL_PIPELINE_TESS_STATE_CREATE_INFO m_struct;
+    const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_offset2d_struct_wrapper
+{
+public:
+    xgl_offset2d_struct_wrapper();
+    xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
+    xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
+
+    virtual ~xgl_offset2d_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    int32_t get_x() { return m_struct.x; }
+    void set_x(int32_t inValue) { m_struct.x = inValue; }
+    int32_t get_y() { return m_struct.y; }
+    void set_y(int32_t inValue) { m_struct.y = inValue; }
+
+
+private:
+    XGL_OFFSET2D m_struct;
+    const XGL_OFFSET2D* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_queue_semaphore_create_info_struct_wrapper
+{
+public:
+    xgl_queue_semaphore_create_info_struct_wrapper();
+    xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
+    xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_queue_semaphore_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_initialCount() { return m_struct.initialCount; }
+    void set_initialCount(uint32_t inValue) { m_struct.initialCount = inValue; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_QUEUE_SEMAPHORE_CREATE_INFO m_struct;
+    const XGL_QUEUE_SEMAPHORE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_clear_color_value_struct_wrapper
+{
+public:
+    xgl_clear_color_value_struct_wrapper();
+    xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct);
+    xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct);
+
+    virtual ~xgl_clear_color_value_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+
+
+private:
+    XGL_CLEAR_COLOR_VALUE m_struct;
+    const XGL_CLEAR_COLOR_VALUE* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_buffer_memory_barrier_struct_wrapper
+{
+public:
+    xgl_buffer_memory_barrier_struct_wrapper();
+    xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct);
+    xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct);
+
+    virtual ~xgl_buffer_memory_barrier_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
+    void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
+    XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
+    void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
+    XGL_BUFFER get_buffer() { return m_struct.buffer; }
+    void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
+    XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+    void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+    XGL_GPU_SIZE get_size() { return m_struct.size; }
+    void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+
+
+private:
+    XGL_BUFFER_MEMORY_BARRIER m_struct;
+    const XGL_BUFFER_MEMORY_BARRIER* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_ms_state_create_info_struct_wrapper
+{
+public:
+    xgl_pipeline_ms_state_create_info_struct_wrapper();
+    xgl_pipeline_ms_state_create_info_struct_wrapper(XGL_PIPELINE_MS_STATE_CREATE_INFO* pInStruct);
+    xgl_pipeline_ms_state_create_info_struct_wrapper(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_pipeline_ms_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_samples() { return m_struct.samples; }
+    void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
+    bool32_t get_multisampleEnable() { return m_struct.multisampleEnable; }
+    void set_multisampleEnable(bool32_t inValue) { m_struct.multisampleEnable = inValue; }
+    bool32_t get_sampleShadingEnable() { return m_struct.sampleShadingEnable; }
+    void set_sampleShadingEnable(bool32_t inValue) { m_struct.sampleShadingEnable = inValue; }
+    float get_minSampleShading() { return m_struct.minSampleShading; }
+    void set_minSampleShading(float inValue) { m_struct.minSampleShading = inValue; }
+    XGL_SAMPLE_MASK get_sampleMask() { return m_struct.sampleMask; }
+    void set_sampleMask(XGL_SAMPLE_MASK inValue) { m_struct.sampleMask = inValue; }
+
+
+private:
+    XGL_PIPELINE_MS_STATE_CREATE_INFO m_struct;
+    const XGL_PIPELINE_MS_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_rs_state_create_info_struct_wrapper
+{
+public:
+    xgl_pipeline_rs_state_create_info_struct_wrapper();
+    xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
+    xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    bool32_t get_depthClipEnable() { return m_struct.depthClipEnable; }
+    void set_depthClipEnable(bool32_t inValue) { m_struct.depthClipEnable = inValue; }
+    bool32_t get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; }
+    void set_rasterizerDiscardEnable(bool32_t inValue) { m_struct.rasterizerDiscardEnable = inValue; }
+    bool32_t get_programPointSize() { return m_struct.programPointSize; }
+    void set_programPointSize(bool32_t inValue) { m_struct.programPointSize = inValue; }
+    XGL_COORDINATE_ORIGIN get_pointOrigin() { return m_struct.pointOrigin; }
+    void set_pointOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.pointOrigin = inValue; }
+    XGL_PROVOKING_VERTEX_CONVENTION get_provokingVertex() { return m_struct.provokingVertex; }
+    void set_provokingVertex(XGL_PROVOKING_VERTEX_CONVENTION inValue) { m_struct.provokingVertex = inValue; }
+    XGL_FILL_MODE get_fillMode() { return m_struct.fillMode; }
+    void set_fillMode(XGL_FILL_MODE inValue) { m_struct.fillMode = inValue; }
+    XGL_CULL_MODE get_cullMode() { return m_struct.cullMode; }
+    void set_cullMode(XGL_CULL_MODE inValue) { m_struct.cullMode = inValue; }
+    XGL_FACE_ORIENTATION get_frontFace() { return m_struct.frontFace; }
+    void set_frontFace(XGL_FACE_ORIENTATION inValue) { m_struct.frontFace = inValue; }
+
+
+private:
+    XGL_PIPELINE_RS_STATE_CREATE_INFO m_struct;
+    const XGL_PIPELINE_RS_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_create_info_struct_wrapper
+{
+public:
+    xgl_image_create_info_struct_wrapper();
+    xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct);
+    xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_image_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_IMAGE_TYPE get_imageType() { return m_struct.imageType; }
+    void set_imageType(XGL_IMAGE_TYPE inValue) { m_struct.imageType = inValue; }
+    XGL_FORMAT get_format() { return m_struct.format; }
+    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+    XGL_EXTENT3D get_extent() { return m_struct.extent; }
+    void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+    uint32_t get_mipLevels() { return m_struct.mipLevels; }
+    void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
+    uint32_t get_arraySize() { return m_struct.arraySize; }
+    void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+    uint32_t get_samples() { return m_struct.samples; }
+    void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
+    XGL_IMAGE_TILING get_tiling() { return m_struct.tiling; }
+    void set_tiling(XGL_IMAGE_TILING inValue) { m_struct.tiling = inValue; }
+    XGL_FLAGS get_usage() { return m_struct.usage; }
+    void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_IMAGE_CREATE_INFO m_struct;
+    const XGL_IMAGE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_images_struct_wrapper
+{
+public:
+    xgl_update_images_struct_wrapper();
+    xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct);
+    xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct);
+
+    virtual ~xgl_update_images_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+    void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+    uint32_t get_index() { return m_struct.index; }
+    void set_index(uint32_t inValue) { m_struct.index = inValue; }
+    uint32_t get_count() { return m_struct.count; }
+    void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+    XGL_UPDATE_IMAGES m_struct;
+    const XGL_UPDATE_IMAGES* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_cmd_buffer_begin_info_struct_wrapper
+{
+public:
+    xgl_cmd_buffer_begin_info_struct_wrapper();
+    xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
+    xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
+
+    virtual ~xgl_cmd_buffer_begin_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_CMD_BUFFER_BEGIN_INFO m_struct;
+    const XGL_CMD_BUFFER_BEGIN_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_view_create_info_struct_wrapper
+{
+public:
+    xgl_image_view_create_info_struct_wrapper();
+    xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
+    xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_image_view_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_IMAGE get_image() { return m_struct.image; }
+    void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+    XGL_IMAGE_VIEW_TYPE get_viewType() { return m_struct.viewType; }
+    void set_viewType(XGL_IMAGE_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
+    XGL_FORMAT get_format() { return m_struct.format; }
+    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+    XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
+    void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
+    XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
+    void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
+    float get_minLod() { return m_struct.minLod; }
+    void set_minLod(float inValue) { m_struct.minLod = inValue; }
+
+
+private:
+    XGL_IMAGE_VIEW_CREATE_INFO m_struct;
+    const XGL_IMAGE_VIEW_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_graphics_pipeline_create_info_struct_wrapper
+{
+public:
+    xgl_graphics_pipeline_create_info_struct_wrapper();
+    xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
+    xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_graphics_pipeline_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+    XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
+    void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
+
+
+private:
+    XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct;
+    const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_rect_struct_wrapper
+{
+public:
+    xgl_rect_struct_wrapper();
+    xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
+    xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
+
+    virtual ~xgl_rect_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_OFFSET2D get_offset() { return m_struct.offset; }
+    void set_offset(XGL_OFFSET2D inValue) { m_struct.offset = inValue; }
+    XGL_EXTENT2D get_extent() { return m_struct.extent; }
+    void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
+
+
+private:
+    XGL_RECT m_struct;
+    const XGL_RECT* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_cmd_buffer_graphics_begin_info_struct_wrapper
+{
+public:
+    xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
+    xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
+    xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
+
+    virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_RENDER_PASS get_renderPass() { return m_struct.renderPass; }
+    void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = inValue; }
+
+
+private:
+    XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO m_struct;
+    const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_device_queue_create_info_struct_wrapper
+{
+public:
+    xgl_device_queue_create_info_struct_wrapper();
+    xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
+    xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_device_queue_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    uint32_t get_queueNodeIndex() { return m_struct.queueNodeIndex; }
+    void set_queueNodeIndex(uint32_t inValue) { m_struct.queueNodeIndex = inValue; }
+    uint32_t get_queueCount() { return m_struct.queueCount; }
+    void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
+
+
+private:
+    XGL_DEVICE_QUEUE_CREATE_INFO m_struct;
+    const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_open_info_struct_wrapper
+{
+public:
+    xgl_memory_open_info_struct_wrapper();
+    xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct);
+    xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct);
+
+    virtual ~xgl_memory_open_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_GPU_MEMORY get_sharedMem() { return m_struct.sharedMem; }
+    void set_sharedMem(XGL_GPU_MEMORY inValue) { m_struct.sharedMem = inValue; }
+
+
+private:
+    XGL_MEMORY_OPEN_INFO m_struct;
+    const XGL_MEMORY_OPEN_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_as_copy_struct_wrapper
+{
+public:
+    xgl_update_as_copy_struct_wrapper();
+    xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct);
+    xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct);
+
+    virtual ~xgl_update_as_copy_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+    void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+    XGL_DESCRIPTOR_SET get_descriptorSet() { return m_struct.descriptorSet; }
+    void set_descriptorSet(XGL_DESCRIPTOR_SET inValue) { m_struct.descriptorSet = inValue; }
+    uint32_t get_descriptorIndex() { return m_struct.descriptorIndex; }
+    void set_descriptorIndex(uint32_t inValue) { m_struct.descriptorIndex = inValue; }
+    uint32_t get_count() { return m_struct.count; }
+    void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+    XGL_UPDATE_AS_COPY m_struct;
+    const XGL_UPDATE_AS_COPY* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_copy_struct_wrapper
+{
+public:
+    xgl_image_copy_struct_wrapper();
+    xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct);
+    xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct);
+
+    virtual ~xgl_image_copy_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
+    void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
+    XGL_OFFSET3D get_srcOffset() { return m_struct.srcOffset; }
+    void set_srcOffset(XGL_OFFSET3D inValue) { m_struct.srcOffset = inValue; }
+    XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
+    void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
+    XGL_OFFSET3D get_destOffset() { return m_struct.destOffset; }
+    void set_destOffset(XGL_OFFSET3D inValue) { m_struct.destOffset = inValue; }
+    XGL_EXTENT3D get_extent() { return m_struct.extent; }
+    void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+
+
+private:
+    XGL_IMAGE_COPY m_struct;
+    const XGL_IMAGE_COPY* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_resolve_struct_wrapper
+{
+public:
+    xgl_image_resolve_struct_wrapper();
+    xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct);
+    xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct);
+
+    virtual ~xgl_image_resolve_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
+    void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
+    XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; }
+    void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; }
+    XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
+    void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
+    XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; }
+    void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; }
+    XGL_EXTENT2D get_extent() { return m_struct.extent; }
+    void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
+
+
+private:
+    XGL_IMAGE_RESOLVE m_struct;
+    const XGL_IMAGE_RESOLVE* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_color_attachment_bind_info_struct_wrapper
+{
+public:
+    xgl_color_attachment_bind_info_struct_wrapper();
+    xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+    xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+
+    virtual ~xgl_color_attachment_bind_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_COLOR_ATTACHMENT_VIEW get_view() { return m_struct.view; }
+    void set_view(XGL_COLOR_ATTACHMENT_VIEW inValue) { m_struct.view = inValue; }
+    XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
+    void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+
+
+private:
+    XGL_COLOR_ATTACHMENT_BIND_INFO m_struct;
+    const XGL_COLOR_ATTACHMENT_BIND_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_ds_state_create_info_struct_wrapper
+{
+public:
+    xgl_dynamic_ds_state_create_info_struct_wrapper();
+    xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
+    xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_dynamic_ds_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    float get_minDepth() { return m_struct.minDepth; }
+    void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
+    float get_maxDepth() { return m_struct.maxDepth; }
+    void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
+    uint32_t get_stencilReadMask() { return m_struct.stencilReadMask; }
+    void set_stencilReadMask(uint32_t inValue) { m_struct.stencilReadMask = inValue; }
+    uint32_t get_stencilWriteMask() { return m_struct.stencilWriteMask; }
+    void set_stencilWriteMask(uint32_t inValue) { m_struct.stencilWriteMask = inValue; }
+    uint32_t get_stencilFrontRef() { return m_struct.stencilFrontRef; }
+    void set_stencilFrontRef(uint32_t inValue) { m_struct.stencilFrontRef = inValue; }
+    uint32_t get_stencilBackRef() { return m_struct.stencilBackRef; }
+    void set_stencilBackRef(uint32_t inValue) { m_struct.stencilBackRef = inValue; }
+
+
+private:
+    XGL_DYNAMIC_DS_STATE_CREATE_INFO m_struct;
+    const XGL_DYNAMIC_DS_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_memory_barrier_struct_wrapper
+{
+public:
+    xgl_image_memory_barrier_struct_wrapper();
+    xgl_image_memory_barrier_struct_wrapper(XGL_IMAGE_MEMORY_BARRIER* pInStruct);
+    xgl_image_memory_barrier_struct_wrapper(const XGL_IMAGE_MEMORY_BARRIER* pInStruct);
+
+    virtual ~xgl_image_memory_barrier_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
+    void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
+    XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
+    void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
+    XGL_IMAGE_LAYOUT get_oldLayout() { return m_struct.oldLayout; }
+    void set_oldLayout(XGL_IMAGE_LAYOUT inValue) { m_struct.oldLayout = inValue; }
+    XGL_IMAGE_LAYOUT get_newLayout() { return m_struct.newLayout; }
+    void set_newLayout(XGL_IMAGE_LAYOUT inValue) { m_struct.newLayout = inValue; }
+    XGL_IMAGE get_image() { return m_struct.image; }
+    void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+    XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
+    void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
+
+
+private:
+    XGL_IMAGE_MEMORY_BARRIER m_struct;
+    const XGL_IMAGE_MEMORY_BARRIER* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_ds_state_create_info_struct_wrapper
+{
+public:
+    xgl_pipeline_ds_state_create_info_struct_wrapper();
+    xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
+    xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_pipeline_ds_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_FORMAT get_format() { return m_struct.format; }
+    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+    bool32_t get_depthTestEnable() { return m_struct.depthTestEnable; }
+    void set_depthTestEnable(bool32_t inValue) { m_struct.depthTestEnable = inValue; }
+    bool32_t get_depthWriteEnable() { return m_struct.depthWriteEnable; }
+    void set_depthWriteEnable(bool32_t inValue) { m_struct.depthWriteEnable = inValue; }
+    XGL_COMPARE_FUNC get_depthFunc() { return m_struct.depthFunc; }
+    void set_depthFunc(XGL_COMPARE_FUNC inValue) { m_struct.depthFunc = inValue; }
+    bool32_t get_depthBoundsEnable() { return m_struct.depthBoundsEnable; }
+    void set_depthBoundsEnable(bool32_t inValue) { m_struct.depthBoundsEnable = inValue; }
+    bool32_t get_stencilTestEnable() { return m_struct.stencilTestEnable; }
+    void set_stencilTestEnable(bool32_t inValue) { m_struct.stencilTestEnable = inValue; }
+    XGL_STENCIL_OP_STATE get_front() { return m_struct.front; }
+    void set_front(XGL_STENCIL_OP_STATE inValue) { m_struct.front = inValue; }
+    XGL_STENCIL_OP_STATE get_back() { return m_struct.back; }
+    void set_back(XGL_STENCIL_OP_STATE inValue) { m_struct.back = inValue; }
+
+
+private:
+    XGL_PIPELINE_DS_STATE_CREATE_INFO m_struct;
+    const XGL_PIPELINE_DS_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_barrier_struct_wrapper
+{
+public:
+    xgl_pipeline_barrier_struct_wrapper();
+    xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct);
+    xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct);
+
+    virtual ~xgl_pipeline_barrier_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_eventCount() { return m_struct.eventCount; }
+    void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
+    XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
+    void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
+    uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
+    void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
+
+
+private:
+    XGL_PIPELINE_BARRIER m_struct;
+    const XGL_PIPELINE_BARRIER* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_physical_gpu_memory_properties_struct_wrapper
+{
+public:
+    xgl_physical_gpu_memory_properties_struct_wrapper();
+    xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
+    xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
+
+    virtual ~xgl_physical_gpu_memory_properties_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    bool32_t get_supportsMigration() { return m_struct.supportsMigration; }
+    void set_supportsMigration(bool32_t inValue) { m_struct.supportsMigration = inValue; }
+    bool32_t get_supportsPinning() { return m_struct.supportsPinning; }
+    void set_supportsPinning(bool32_t inValue) { m_struct.supportsPinning = inValue; }
+
+
+private:
+    XGL_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct;
+    const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_alloc_image_info_struct_wrapper
+{
+public:
+    xgl_memory_alloc_image_info_struct_wrapper();
+    xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
+    xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
+
+    virtual ~xgl_memory_alloc_image_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_FLAGS get_usage() { return m_struct.usage; }
+    void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+    XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
+    void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
+    uint32_t get_samples() { return m_struct.samples; }
+    void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
+
+
+private:
+    XGL_MEMORY_ALLOC_IMAGE_INFO m_struct;
+    const XGL_MEMORY_ALLOC_IMAGE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_sampler_textures_struct_wrapper
+{
+public:
+    xgl_update_sampler_textures_struct_wrapper();
+    xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
+    xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
+
+    virtual ~xgl_update_sampler_textures_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_index() { return m_struct.index; }
+    void set_index(uint32_t inValue) { m_struct.index = inValue; }
+    uint32_t get_count() { return m_struct.count; }
+    void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+    XGL_UPDATE_SAMPLER_TEXTURES m_struct;
+    const XGL_UPDATE_SAMPLER_TEXTURES* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_peer_memory_open_info_struct_wrapper
+{
+public:
+    xgl_peer_memory_open_info_struct_wrapper();
+    xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
+    xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
+
+    virtual ~xgl_peer_memory_open_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; }
+    void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; }
+
+
+private:
+    XGL_PEER_MEMORY_OPEN_INFO m_struct;
+    const XGL_PEER_MEMORY_OPEN_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_type_count_struct_wrapper
+{
+public:
+    xgl_descriptor_type_count_struct_wrapper();
+    xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
+    xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
+
+    virtual ~xgl_descriptor_type_count_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_DESCRIPTOR_TYPE get_type() { return m_struct.type; }
+    void set_type(XGL_DESCRIPTOR_TYPE inValue) { m_struct.type = inValue; }
+    uint32_t get_count() { return m_struct.count; }
+    void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+    XGL_DESCRIPTOR_TYPE_COUNT m_struct;
+    const XGL_DESCRIPTOR_TYPE_COUNT* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dispatch_indirect_cmd_struct_wrapper
+{
+public:
+    xgl_dispatch_indirect_cmd_struct_wrapper();
+    xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct);
+    xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct);
+
+    virtual ~xgl_dispatch_indirect_cmd_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    uint32_t get_x() { return m_struct.x; }
+    void set_x(uint32_t inValue) { m_struct.x = inValue; }
+    uint32_t get_y() { return m_struct.y; }
+    void set_y(uint32_t inValue) { m_struct.y = inValue; }
+    uint32_t get_z() { return m_struct.z; }
+    void set_z(uint32_t inValue) { m_struct.z = inValue; }
+
+
+private:
+    XGL_DISPATCH_INDIRECT_CMD m_struct;
+    const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_region_create_info_struct_wrapper
+{
+public:
+    xgl_descriptor_region_create_info_struct_wrapper();
+    xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
+    xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_descriptor_region_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    uint32_t get_count() { return m_struct.count; }
+    void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+    XGL_DESCRIPTOR_REGION_CREATE_INFO m_struct;
+    const XGL_DESCRIPTOR_REGION_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_viewport_struct_wrapper
+{
+public:
+    xgl_viewport_struct_wrapper();
+    xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct);
+    xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct);
+
+    virtual ~xgl_viewport_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    float get_originX() { return m_struct.originX; }
+    void set_originX(float inValue) { m_struct.originX = inValue; }
+    float get_originY() { return m_struct.originY; }
+    void set_originY(float inValue) { m_struct.originY = inValue; }
+    float get_width() { return m_struct.width; }
+    void set_width(float inValue) { m_struct.width = inValue; }
+    float get_height() { return m_struct.height; }
+    void set_height(float inValue) { m_struct.height = inValue; }
+    float get_minDepth() { return m_struct.minDepth; }
+    void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
+    float get_maxDepth() { return m_struct.maxDepth; }
+    void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
+
+
+private:
+    XGL_VIEWPORT m_struct;
+    const XGL_VIEWPORT* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_depth_stencil_view_create_info_struct_wrapper
+{
+public:
+    xgl_depth_stencil_view_create_info_struct_wrapper();
+    xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
+    xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_IMAGE get_image() { return m_struct.image; }
+    void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+    uint32_t get_mipLevel() { return m_struct.mipLevel; }
+    void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
+    uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+    void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+    uint32_t get_arraySize() { return m_struct.arraySize; }
+    void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+    XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
+    void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
+    XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
+    void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct;
+    const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_query_pool_create_info_struct_wrapper
+{
+public:
+    xgl_query_pool_create_info_struct_wrapper();
+    xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct);
+    xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_query_pool_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_QUERY_TYPE get_queryType() { return m_struct.queryType; }
+    void set_queryType(XGL_QUERY_TYPE inValue) { m_struct.queryType = inValue; }
+    uint32_t get_slots() { return m_struct.slots; }
+    void set_slots(uint32_t inValue) { m_struct.slots = inValue; }
+
+
+private:
+    XGL_QUERY_POOL_CREATE_INFO m_struct;
+    const XGL_QUERY_POOL_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_cmd_buffer_create_info_struct_wrapper
+{
+public:
+    xgl_cmd_buffer_create_info_struct_wrapper();
+    xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
+    xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_cmd_buffer_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_QUEUE_TYPE get_queueType() { return m_struct.queueType; }
+    void set_queueType(XGL_QUEUE_TYPE inValue) { m_struct.queueType = inValue; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+    XGL_CMD_BUFFER_CREATE_INFO m_struct;
+    const XGL_CMD_BUFFER_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_depth_stencil_bind_info_struct_wrapper
+{
+public:
+    xgl_depth_stencil_bind_info_struct_wrapper();
+    xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
+    xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
+
+    virtual ~xgl_depth_stencil_bind_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_DEPTH_STENCIL_VIEW get_view() { return m_struct.view; }
+    void set_view(XGL_DEPTH_STENCIL_VIEW inValue) { m_struct.view = inValue; }
+    XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
+    void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+
+
+private:
+    XGL_DEPTH_STENCIL_BIND_INFO m_struct;
+    const XGL_DEPTH_STENCIL_BIND_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_requirements_struct_wrapper
+{
+public:
+    xgl_memory_requirements_struct_wrapper();
+    xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct);
+    xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct);
+
+    virtual ~xgl_memory_requirements_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_GPU_SIZE get_size() { return m_struct.size; }
+    void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+    XGL_GPU_SIZE get_alignment() { return m_struct.alignment; }
+    void set_alignment(XGL_GPU_SIZE inValue) { m_struct.alignment = inValue; }
+    XGL_GPU_SIZE get_granularity() { return m_struct.granularity; }
+    void set_granularity(XGL_GPU_SIZE inValue) { m_struct.granularity = inValue; }
+    XGL_FLAGS get_memProps() { return m_struct.memProps; }
+    void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
+    XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
+    void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
+
+
+private:
+    XGL_MEMORY_REQUIREMENTS m_struct;
+    const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_queue_semaphore_open_info_struct_wrapper
+{
+public:
+    xgl_queue_semaphore_open_info_struct_wrapper();
+    xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
+    xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
+
+    virtual ~xgl_queue_semaphore_open_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; }
+    void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = inValue; }
+
+
+private:
+    XGL_QUEUE_SEMAPHORE_OPEN_INFO m_struct;
+    const XGL_QUEUE_SEMAPHORE_OPEN_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_barrier_struct_wrapper
+{
+public:
+    xgl_memory_barrier_struct_wrapper();
+    xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct);
+    xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct);
+
+    virtual ~xgl_memory_barrier_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
+    void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
+    XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
+    void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
+
+
+private:
+    XGL_MEMORY_BARRIER m_struct;
+    const XGL_MEMORY_BARRIER* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_physical_gpu_performance_struct_wrapper
+{
+public:
+    xgl_physical_gpu_performance_struct_wrapper();
+    xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
+    xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
+
+    virtual ~xgl_physical_gpu_performance_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    float get_maxGpuClock() { return m_struct.maxGpuClock; }
+    void set_maxGpuClock(float inValue) { m_struct.maxGpuClock = inValue; }
+    float get_aluPerClock() { return m_struct.aluPerClock; }
+    void set_aluPerClock(float inValue) { m_struct.aluPerClock = inValue; }
+    float get_texPerClock() { return m_struct.texPerClock; }
+    void set_texPerClock(float inValue) { m_struct.texPerClock = inValue; }
+    float get_primsPerClock() { return m_struct.primsPerClock; }
+    void set_primsPerClock(float inValue) { m_struct.primsPerClock = inValue; }
+    float get_pixelsPerClock() { return m_struct.pixelsPerClock; }
+    void set_pixelsPerClock(float inValue) { m_struct.pixelsPerClock = inValue; }
+
+
+private:
+    XGL_PHYSICAL_GPU_PERFORMANCE m_struct;
+    const XGL_PHYSICAL_GPU_PERFORMANCE* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_channel_mapping_struct_wrapper
+{
+public:
+    xgl_channel_mapping_struct_wrapper();
+    xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct);
+    xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct);
+
+    virtual ~xgl_channel_mapping_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_CHANNEL_SWIZZLE get_r() { return m_struct.r; }
+    void set_r(XGL_CHANNEL_SWIZZLE inValue) { m_struct.r = inValue; }
+    XGL_CHANNEL_SWIZZLE get_g() { return m_struct.g; }
+    void set_g(XGL_CHANNEL_SWIZZLE inValue) { m_struct.g = inValue; }
+    XGL_CHANNEL_SWIZZLE get_b() { return m_struct.b; }
+    void set_b(XGL_CHANNEL_SWIZZLE inValue) { m_struct.b = inValue; }
+    XGL_CHANNEL_SWIZZLE get_a() { return m_struct.a; }
+    void set_a(XGL_CHANNEL_SWIZZLE inValue) { m_struct.a = inValue; }
+
+
+private:
+    XGL_CHANNEL_MAPPING m_struct;
+    const XGL_CHANNEL_MAPPING* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_clear_color_struct_wrapper
+{
+public:
+    xgl_clear_color_struct_wrapper();
+    xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct);
+    xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct);
+
+    virtual ~xgl_clear_color_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_CLEAR_COLOR_VALUE get_color() { return m_struct.color; }
+    void set_color(XGL_CLEAR_COLOR_VALUE inValue) { m_struct.color = inValue; }
+    bool32_t get_useRawValue() { return m_struct.useRawValue; }
+    void set_useRawValue(bool32_t inValue) { m_struct.useRawValue = inValue; }
+
+
+private:
+    XGL_CLEAR_COLOR m_struct;
+    const XGL_CLEAR_COLOR* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_cb_state_create_info_struct_wrapper
+{
+public:
+    xgl_dynamic_cb_state_create_info_struct_wrapper();
+    xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
+    xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_dynamic_cb_state_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+
+
+private:
+    XGL_DYNAMIC_CB_STATE_CREATE_INFO m_struct;
+    const XGL_DYNAMIC_CB_STATE_CREATE_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_buffer_view_create_info_struct_wrapper
+{
+public:
+    xgl_buffer_view_create_info_struct_wrapper();
+    xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
+    xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_buffer_view_create_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_BUFFER get_buffer() { return m_struct.buffer; }
+    void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
+    XGL_BUFFER_VIEW_TYPE get_viewType() { return m_struct.viewType; }
+    void set_viewType(XGL_BUFFER_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
+    XGL_GPU_SIZE get_stride() { return m_struct.stride; }
+    void set_stride(XGL_GPU_SIZE inValue) { m_struct.stride = inValue; }
+    XGL_FORMAT get_format() { return m_struct.format; }
+    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+    XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
+    void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
+    XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+    void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+    XGL_GPU_SIZE get_range() { return m_struct.range; }
+    void set_range(XGL_GPU_SIZE inValue) { m_struct.range = inValue; }
+
+
+private:
+    XGL_BUFFER_VIEW_CREATE_INFO m_struct;
+    const XGL_BUFFER_VIEW_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -229,51 +2742,14 @@
 
 
 //class declaration
-class xgl_draw_indexed_indirect_cmd_struct_wrapper
+class xgl_event_wait_info_struct_wrapper
 {
 public:
-    xgl_draw_indexed_indirect_cmd_struct_wrapper();
-    xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
-    xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
+    xgl_event_wait_info_struct_wrapper();
+    xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct);
+    xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct);
 
-    virtual ~xgl_draw_indexed_indirect_cmd_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    uint32_t get_indexCount() { return m_struct.indexCount; }
-    void set_indexCount(uint32_t inValue) { m_struct.indexCount = inValue; }
-    uint32_t get_instanceCount() { return m_struct.instanceCount; }
-    void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
-    uint32_t get_firstIndex() { return m_struct.firstIndex; }
-    void set_firstIndex(uint32_t inValue) { m_struct.firstIndex = inValue; }
-    int32_t get_vertexOffset() { return m_struct.vertexOffset; }
-    void set_vertexOffset(int32_t inValue) { m_struct.vertexOffset = inValue; }
-    uint32_t get_firstInstance() { return m_struct.firstInstance; }
-    void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
-
-
-private:
-    XGL_DRAW_INDEXED_INDIRECT_CMD m_struct;
-    const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_as_copy_struct_wrapper
-{
-public:
-    xgl_update_as_copy_struct_wrapper();
-    xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct);
-    xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct);
-
-    virtual ~xgl_update_as_copy_struct_wrapper();
+    virtual ~xgl_event_wait_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -283,19 +2759,17 @@
     XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
     void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
     const void* get_pNext() { return m_struct.pNext; }
-    XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
-    void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
-    XGL_DESCRIPTOR_SET get_descriptorSet() { return m_struct.descriptorSet; }
-    void set_descriptorSet(XGL_DESCRIPTOR_SET inValue) { m_struct.descriptorSet = inValue; }
-    uint32_t get_descriptorIndex() { return m_struct.descriptorIndex; }
-    void set_descriptorIndex(uint32_t inValue) { m_struct.descriptorIndex = inValue; }
-    uint32_t get_count() { return m_struct.count; }
-    void set_count(uint32_t inValue) { m_struct.count = inValue; }
+    uint32_t get_eventCount() { return m_struct.eventCount; }
+    void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
+    XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
+    void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
+    uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
+    void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
 
 
 private:
-    XGL_UPDATE_AS_COPY m_struct;
-    const XGL_UPDATE_AS_COPY* m_origStructAddr;
+    XGL_EVENT_WAIT_INFO m_struct;
+    const XGL_EVENT_WAIT_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -304,29 +2778,33 @@
 
 
 //class declaration
-class xgl_clear_color_struct_wrapper
+class xgl_buffer_image_copy_struct_wrapper
 {
 public:
-    xgl_clear_color_struct_wrapper();
-    xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct);
-    xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct);
+    xgl_buffer_image_copy_struct_wrapper();
+    xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct);
+    xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct);
 
-    virtual ~xgl_clear_color_struct_wrapper();
+    virtual ~xgl_buffer_image_copy_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
     void display_full_txt();
 
     void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_CLEAR_COLOR_VALUE get_color() { return m_struct.color; }
-    void set_color(XGL_CLEAR_COLOR_VALUE inValue) { m_struct.color = inValue; }
-    bool32_t get_useRawValue() { return m_struct.useRawValue; }
-    void set_useRawValue(bool32_t inValue) { m_struct.useRawValue = inValue; }
+    XGL_GPU_SIZE get_bufferOffset() { return m_struct.bufferOffset; }
+    void set_bufferOffset(XGL_GPU_SIZE inValue) { m_struct.bufferOffset = inValue; }
+    XGL_IMAGE_SUBRESOURCE get_imageSubresource() { return m_struct.imageSubresource; }
+    void set_imageSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.imageSubresource = inValue; }
+    XGL_OFFSET3D get_imageOffset() { return m_struct.imageOffset; }
+    void set_imageOffset(XGL_OFFSET3D inValue) { m_struct.imageOffset = inValue; }
+    XGL_EXTENT3D get_imageExtent() { return m_struct.imageExtent; }
+    void set_imageExtent(XGL_EXTENT3D inValue) { m_struct.imageExtent = inValue; }
 
 
 private:
-    XGL_CLEAR_COLOR m_struct;
-    const XGL_CLEAR_COLOR* m_origStructAddr;
+    XGL_BUFFER_IMAGE_COPY m_struct;
+    const XGL_BUFFER_IMAGE_COPY* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -335,45 +2813,14 @@
 
 
 //class declaration
-class xgl_extent2d_struct_wrapper
+class xgl_event_create_info_struct_wrapper
 {
 public:
-    xgl_extent2d_struct_wrapper();
-    xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct);
-    xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct);
+    xgl_event_create_info_struct_wrapper();
+    xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct);
+    xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct);
 
-    virtual ~xgl_extent2d_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    int32_t get_width() { return m_struct.width; }
-    void set_width(int32_t inValue) { m_struct.width = inValue; }
-    int32_t get_height() { return m_struct.height; }
-    void set_height(int32_t inValue) { m_struct.height = inValue; }
-
-
-private:
-    XGL_EXTENT2D m_struct;
-    const XGL_EXTENT2D* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_framebuffer_create_info_struct_wrapper
-{
-public:
-    xgl_framebuffer_create_info_struct_wrapper();
-    xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
-    xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_framebuffer_create_info_struct_wrapper();
+    virtual ~xgl_event_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -383,124 +2830,13 @@
     XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
     void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
     const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
-    void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
-    const XGL_DEPTH_STENCIL_BIND_INFO* get_pDepthStencilAttachment() { return m_struct.pDepthStencilAttachment; }
-    uint32_t get_sampleCount() { return m_struct.sampleCount; }
-    void set_sampleCount(uint32_t inValue) { m_struct.sampleCount = inValue; }
-    uint32_t get_width() { return m_struct.width; }
-    void set_width(uint32_t inValue) { m_struct.width = inValue; }
-    uint32_t get_height() { return m_struct.height; }
-    void set_height(uint32_t inValue) { m_struct.height = inValue; }
-    uint32_t get_layers() { return m_struct.layers; }
-    void set_layers(uint32_t inValue) { m_struct.layers = inValue; }
+    XGL_FLAGS get_flags() { return m_struct.flags; }
+    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
 
 
 private:
-    XGL_FRAMEBUFFER_CREATE_INFO m_struct;
-    const XGL_FRAMEBUFFER_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_alloc_callbacks_struct_wrapper
-{
-public:
-    xgl_alloc_callbacks_struct_wrapper();
-    xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct);
-    xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct);
-
-    virtual ~xgl_alloc_callbacks_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    void* get_pUserData() { return m_struct.pUserData; }
-    void set_pUserData(void* inValue) { m_struct.pUserData = inValue; }
-    XGL_ALLOC_FUNCTION get_pfnAlloc() { return m_struct.pfnAlloc; }
-    void set_pfnAlloc(XGL_ALLOC_FUNCTION inValue) { m_struct.pfnAlloc = inValue; }
-    XGL_FREE_FUNCTION get_pfnFree() { return m_struct.pfnFree; }
-    void set_pfnFree(XGL_FREE_FUNCTION inValue) { m_struct.pfnFree = inValue; }
-
-
-private:
-    XGL_ALLOC_CALLBACKS m_struct;
-    const XGL_ALLOC_CALLBACKS* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_requirements_struct_wrapper
-{
-public:
-    xgl_memory_requirements_struct_wrapper();
-    xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct);
-    xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct);
-
-    virtual ~xgl_memory_requirements_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_GPU_SIZE get_size() { return m_struct.size; }
-    void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
-    XGL_GPU_SIZE get_alignment() { return m_struct.alignment; }
-    void set_alignment(XGL_GPU_SIZE inValue) { m_struct.alignment = inValue; }
-    XGL_GPU_SIZE get_granularity() { return m_struct.granularity; }
-    void set_granularity(XGL_GPU_SIZE inValue) { m_struct.granularity = inValue; }
-    XGL_FLAGS get_memProps() { return m_struct.memProps; }
-    void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
-    XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
-    void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
-
-
-private:
-    XGL_MEMORY_REQUIREMENTS m_struct;
-    const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_link_const_buffer_struct_wrapper
-{
-public:
-    xgl_link_const_buffer_struct_wrapper();
-    xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct);
-    xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct);
-
-    virtual ~xgl_link_const_buffer_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    uint32_t get_bufferId() { return m_struct.bufferId; }
-    void set_bufferId(uint32_t inValue) { m_struct.bufferId = inValue; }
-    size_t get_bufferSize() { return m_struct.bufferSize; }
-    void set_bufferSize(size_t inValue) { m_struct.bufferSize = inValue; }
-    const void* get_pBufferData() { return m_struct.pBufferData; }
-
-
-private:
-    XGL_LINK_CONST_BUFFER m_struct;
-    const XGL_LINK_CONST_BUFFER* m_origStructAddr;
+    XGL_EVENT_CREATE_INFO m_struct;
+    const XGL_EVENT_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -564,81 +2900,6 @@
 
 
 //class declaration
-class xgl_device_create_info_struct_wrapper
-{
-public:
-    xgl_device_create_info_struct_wrapper();
-    xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct);
-    xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_device_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_queueRecordCount() { return m_struct.queueRecordCount; }
-    void set_queueRecordCount(uint32_t inValue) { m_struct.queueRecordCount = inValue; }
-    uint32_t get_extensionCount() { return m_struct.extensionCount; }
-    void set_extensionCount(uint32_t inValue) { m_struct.extensionCount = inValue; }
-    XGL_VALIDATION_LEVEL get_maxValidationLevel() { return m_struct.maxValidationLevel; }
-    void set_maxValidationLevel(XGL_VALIDATION_LEVEL inValue) { m_struct.maxValidationLevel = inValue; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_DEVICE_CREATE_INFO m_struct;
-    const XGL_DEVICE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_resolve_struct_wrapper
-{
-public:
-    xgl_image_resolve_struct_wrapper();
-    xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct);
-    xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct);
-
-    virtual ~xgl_image_resolve_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
-    void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
-    XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; }
-    void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; }
-    XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
-    void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
-    XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; }
-    void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; }
-    XGL_EXTENT2D get_extent() { return m_struct.extent; }
-    void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
-
-
-private:
-    XGL_IMAGE_RESOLVE m_struct;
-    const XGL_IMAGE_RESOLVE* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
 class xgl_image_view_attach_info_struct_wrapper
 {
 public:
@@ -673,14 +2934,14 @@
 
 
 //class declaration
-class xgl_fence_create_info_struct_wrapper
+class xgl_memory_alloc_buffer_info_struct_wrapper
 {
 public:
-    xgl_fence_create_info_struct_wrapper();
-    xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct);
-    xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct);
+    xgl_memory_alloc_buffer_info_struct_wrapper();
+    xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
+    xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
 
-    virtual ~xgl_fence_create_info_struct_wrapper();
+    virtual ~xgl_memory_alloc_buffer_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -690,55 +2951,13 @@
     XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
     void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
     const void* get_pNext() { return m_struct.pNext; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+    XGL_FLAGS get_usage() { return m_struct.usage; }
+    void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
 
 
 private:
-    XGL_FENCE_CREATE_INFO m_struct;
-    const XGL_FENCE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dynamic_rs_state_create_info_struct_wrapper
-{
-public:
-    xgl_dynamic_rs_state_create_info_struct_wrapper();
-    xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
-    xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_dynamic_rs_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    float get_depthBias() { return m_struct.depthBias; }
-    void set_depthBias(float inValue) { m_struct.depthBias = inValue; }
-    float get_depthBiasClamp() { return m_struct.depthBiasClamp; }
-    void set_depthBiasClamp(float inValue) { m_struct.depthBiasClamp = inValue; }
-    float get_slopeScaledDepthBias() { return m_struct.slopeScaledDepthBias; }
-    void set_slopeScaledDepthBias(float inValue) { m_struct.slopeScaledDepthBias = inValue; }
-    float get_pointSize() { return m_struct.pointSize; }
-    void set_pointSize(float inValue) { m_struct.pointSize = inValue; }
-    float get_pointFadeThreshold() { return m_struct.pointFadeThreshold; }
-    void set_pointFadeThreshold(float inValue) { m_struct.pointFadeThreshold = inValue; }
-    float get_lineWidth() { return m_struct.lineWidth; }
-    void set_lineWidth(float inValue) { m_struct.lineWidth = inValue; }
-
-
-private:
-    XGL_DYNAMIC_RS_STATE_CREATE_INFO m_struct;
-    const XGL_DYNAMIC_RS_STATE_CREATE_INFO* m_origStructAddr;
+    XGL_MEMORY_ALLOC_BUFFER_INFO m_struct;
+    const XGL_MEMORY_ALLOC_BUFFER_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -780,29 +2999,31 @@
 
 
 //class declaration
-class xgl_color_attachment_bind_info_struct_wrapper
+class xgl_image_memory_bind_info_struct_wrapper
 {
 public:
-    xgl_color_attachment_bind_info_struct_wrapper();
-    xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
-    xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+    xgl_image_memory_bind_info_struct_wrapper();
+    xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
+    xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
 
-    virtual ~xgl_color_attachment_bind_info_struct_wrapper();
+    virtual ~xgl_image_memory_bind_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
     void display_full_txt();
 
     void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_COLOR_ATTACHMENT_VIEW get_view() { return m_struct.view; }
-    void set_view(XGL_COLOR_ATTACHMENT_VIEW inValue) { m_struct.view = inValue; }
-    XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
-    void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+    XGL_IMAGE_SUBRESOURCE get_subresource() { return m_struct.subresource; }
+    void set_subresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.subresource = inValue; }
+    XGL_OFFSET3D get_offset() { return m_struct.offset; }
+    void set_offset(XGL_OFFSET3D inValue) { m_struct.offset = inValue; }
+    XGL_EXTENT3D get_extent() { return m_struct.extent; }
+    void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
 
 
 private:
-    XGL_COLOR_ATTACHMENT_BIND_INFO m_struct;
-    const XGL_COLOR_ATTACHMENT_BIND_INFO* m_origStructAddr;
+    XGL_IMAGE_MEMORY_BIND_INFO m_struct;
+    const XGL_IMAGE_MEMORY_BIND_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -811,158 +3032,14 @@
 
 
 //class declaration
-class xgl_buffer_view_create_info_struct_wrapper
+class xgl_image_memory_requirements_struct_wrapper
 {
 public:
-    xgl_buffer_view_create_info_struct_wrapper();
-    xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
-    xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
+    xgl_image_memory_requirements_struct_wrapper();
+    xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct);
+    xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct);
 
-    virtual ~xgl_buffer_view_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_BUFFER get_buffer() { return m_struct.buffer; }
-    void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
-    XGL_BUFFER_VIEW_TYPE get_viewType() { return m_struct.viewType; }
-    void set_viewType(XGL_BUFFER_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
-    XGL_GPU_SIZE get_stride() { return m_struct.stride; }
-    void set_stride(XGL_GPU_SIZE inValue) { m_struct.stride = inValue; }
-    XGL_FORMAT get_format() { return m_struct.format; }
-    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
-    XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
-    void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
-    XGL_GPU_SIZE get_offset() { return m_struct.offset; }
-    void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
-    XGL_GPU_SIZE get_range() { return m_struct.range; }
-    void set_range(XGL_GPU_SIZE inValue) { m_struct.range = inValue; }
-
-
-private:
-    XGL_BUFFER_VIEW_CREATE_INFO m_struct;
-    const XGL_BUFFER_VIEW_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_queue_semaphore_open_info_struct_wrapper
-{
-public:
-    xgl_queue_semaphore_open_info_struct_wrapper();
-    xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
-    xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
-
-    virtual ~xgl_queue_semaphore_open_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; }
-    void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = inValue; }
-
-
-private:
-    XGL_QUEUE_SEMAPHORE_OPEN_INFO m_struct;
-    const XGL_QUEUE_SEMAPHORE_OPEN_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_cb_state_create_info_struct_wrapper
-{
-public:
-    xgl_pipeline_cb_state_create_info_struct_wrapper();
-    xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
-    xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    bool32_t get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; }
-    void set_alphaToCoverageEnable(bool32_t inValue) { m_struct.alphaToCoverageEnable = inValue; }
-    bool32_t get_logicOpEnable() { return m_struct.logicOpEnable; }
-    void set_logicOpEnable(bool32_t inValue) { m_struct.logicOpEnable = inValue; }
-    XGL_LOGIC_OP get_logicOp() { return m_struct.logicOp; }
-    void set_logicOp(XGL_LOGIC_OP inValue) { m_struct.logicOp = inValue; }
-    uint32_t get_attachmentCount() { return m_struct.attachmentCount; }
-    void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; }
-
-
-private:
-    XGL_PIPELINE_CB_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_CB_STATE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dynamic_cb_state_create_info_struct_wrapper
-{
-public:
-    xgl_dynamic_cb_state_create_info_struct_wrapper();
-    xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
-    xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_dynamic_cb_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-
-
-private:
-    XGL_DYNAMIC_CB_STATE_CREATE_INFO m_struct;
-    const XGL_DYNAMIC_CB_STATE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_memory_requirements_struct_wrapper
-{
-public:
-    xgl_buffer_memory_requirements_struct_wrapper();
-    xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
-    xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
-
-    virtual ~xgl_buffer_memory_requirements_struct_wrapper();
+    virtual ~xgl_image_memory_requirements_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -971,11 +3048,146 @@
     void set_indent(uint32_t indent) { m_indent = indent; }
     XGL_FLAGS get_usage() { return m_struct.usage; }
     void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+    XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
+    void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
+    uint32_t get_samples() { return m_struct.samples; }
+    void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
 
 
 private:
-    XGL_BUFFER_MEMORY_REQUIREMENTS m_struct;
-    const XGL_BUFFER_MEMORY_REQUIREMENTS* m_origStructAddr;
+    XGL_IMAGE_MEMORY_REQUIREMENTS m_struct;
+    const XGL_IMAGE_MEMORY_REQUIREMENTS* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_shader_struct_wrapper
+{
+public:
+    xgl_pipeline_shader_struct_wrapper();
+    xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct);
+    xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct);
+
+    virtual ~xgl_pipeline_shader_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_PIPELINE_SHADER_STAGE get_stage() { return m_struct.stage; }
+    void set_stage(XGL_PIPELINE_SHADER_STAGE inValue) { m_struct.stage = inValue; }
+    XGL_SHADER get_shader() { return m_struct.shader; }
+    void set_shader(XGL_SHADER inValue) { m_struct.shader = inValue; }
+    uint32_t get_linkConstBufferCount() { return m_struct.linkConstBufferCount; }
+    void set_linkConstBufferCount(uint32_t inValue) { m_struct.linkConstBufferCount = inValue; }
+
+
+private:
+    XGL_PIPELINE_SHADER m_struct;
+    const XGL_PIPELINE_SHADER* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_offset3d_struct_wrapper
+{
+public:
+    xgl_offset3d_struct_wrapper();
+    xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
+    xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
+
+    virtual ~xgl_offset3d_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    int32_t get_x() { return m_struct.x; }
+    void set_x(int32_t inValue) { m_struct.x = inValue; }
+    int32_t get_y() { return m_struct.y; }
+    void set_y(int32_t inValue) { m_struct.y = inValue; }
+    int32_t get_z() { return m_struct.z; }
+    void set_z(int32_t inValue) { m_struct.z = inValue; }
+
+
+private:
+    XGL_OFFSET3D m_struct;
+    const XGL_OFFSET3D* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_buffer_view_attach_info_struct_wrapper
+{
+public:
+    xgl_buffer_view_attach_info_struct_wrapper();
+    xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
+    xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
+
+    virtual ~xgl_buffer_view_attach_info_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+    const void* get_pNext() { return m_struct.pNext; }
+    XGL_BUFFER_VIEW get_view() { return m_struct.view; }
+    void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; }
+
+
+private:
+    XGL_BUFFER_VIEW_ATTACH_INFO m_struct;
+    const XGL_BUFFER_VIEW_ATTACH_INFO* m_origStructAddr;
+    uint32_t m_indent;
+    const char m_dummy_prefix;
+    void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_extent3d_struct_wrapper
+{
+public:
+    xgl_extent3d_struct_wrapper();
+    xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct);
+    xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct);
+
+    virtual ~xgl_extent3d_struct_wrapper();
+
+    void display_txt();
+    void display_single_txt();
+    void display_full_txt();
+
+    void set_indent(uint32_t indent) { m_indent = indent; }
+    int32_t get_width() { return m_struct.width; }
+    void set_width(int32_t inValue) { m_struct.width = inValue; }
+    int32_t get_height() { return m_struct.height; }
+    void set_height(int32_t inValue) { m_struct.height = inValue; }
+    int32_t get_depth() { return m_struct.depth; }
+    void set_depth(int32_t inValue) { m_struct.depth = inValue; }
+
+
+private:
+    XGL_EXTENT3D m_struct;
+    const XGL_EXTENT3D* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1014,636 +3226,6 @@
 
 
 //class declaration
-class xgl_descriptor_set_layout_create_info_struct_wrapper
-{
-public:
-    xgl_descriptor_set_layout_create_info_struct_wrapper();
-    xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
-    xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_descriptor_set_layout_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
-    void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
-    uint32_t get_count() { return m_struct.count; }
-    void set_count(uint32_t inValue) { m_struct.count = inValue; }
-    XGL_FLAGS get_stageFlags() { return m_struct.stageFlags; }
-    void set_stageFlags(XGL_FLAGS inValue) { m_struct.stageFlags = inValue; }
-    XGL_SAMPLER get_immutableSampler() { return m_struct.immutableSampler; }
-    void set_immutableSampler(XGL_SAMPLER inValue) { m_struct.immutableSampler = inValue; }
-
-
-private:
-    XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO m_struct;
-    const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_event_wait_info_struct_wrapper
-{
-public:
-    xgl_event_wait_info_struct_wrapper();
-    xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct);
-    xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct);
-
-    virtual ~xgl_event_wait_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_eventCount() { return m_struct.eventCount; }
-    void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
-    XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
-    void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
-    uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
-    void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
-
-
-private:
-    XGL_EVENT_WAIT_INFO m_struct;
-    const XGL_EVENT_WAIT_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_descriptor_region_create_info_struct_wrapper
-{
-public:
-    xgl_descriptor_region_create_info_struct_wrapper();
-    xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
-    xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_descriptor_region_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_count() { return m_struct.count; }
-    void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
-    XGL_DESCRIPTOR_REGION_CREATE_INFO m_struct;
-    const XGL_DESCRIPTOR_REGION_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_alloc_info_struct_wrapper
-{
-public:
-    xgl_memory_alloc_info_struct_wrapper();
-    xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct);
-    xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct);
-
-    virtual ~xgl_memory_alloc_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_GPU_SIZE get_allocationSize() { return m_struct.allocationSize; }
-    void set_allocationSize(XGL_GPU_SIZE inValue) { m_struct.allocationSize = inValue; }
-    XGL_FLAGS get_memProps() { return m_struct.memProps; }
-    void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
-    XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
-    void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
-    XGL_MEMORY_PRIORITY get_memPriority() { return m_struct.memPriority; }
-    void set_memPriority(XGL_MEMORY_PRIORITY inValue) { m_struct.memPriority = inValue; }
-
-
-private:
-    XGL_MEMORY_ALLOC_INFO m_struct;
-    const XGL_MEMORY_ALLOC_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_open_info_struct_wrapper
-{
-public:
-    xgl_memory_open_info_struct_wrapper();
-    xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct);
-    xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct);
-
-    virtual ~xgl_memory_open_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_GPU_MEMORY get_sharedMem() { return m_struct.sharedMem; }
-    void set_sharedMem(XGL_GPU_MEMORY inValue) { m_struct.sharedMem = inValue; }
-
-
-private:
-    XGL_MEMORY_OPEN_INFO m_struct;
-    const XGL_MEMORY_OPEN_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_graphics_pipeline_create_info_struct_wrapper
-{
-public:
-    xgl_graphics_pipeline_create_info_struct_wrapper();
-    xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
-    xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_graphics_pipeline_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-    XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
-    void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
-
-
-private:
-    XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct;
-    const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_shader_stage_create_info_struct_wrapper
-{
-public:
-    xgl_pipeline_shader_stage_create_info_struct_wrapper();
-    xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
-    xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_PIPELINE_SHADER get_shader() { return m_struct.shader; }
-    void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; }
-
-
-private:
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_ms_state_create_info_struct_wrapper
-{
-public:
-    xgl_pipeline_ms_state_create_info_struct_wrapper();
-    xgl_pipeline_ms_state_create_info_struct_wrapper(XGL_PIPELINE_MS_STATE_CREATE_INFO* pInStruct);
-    xgl_pipeline_ms_state_create_info_struct_wrapper(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_pipeline_ms_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_samples() { return m_struct.samples; }
-    void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
-    bool32_t get_multisampleEnable() { return m_struct.multisampleEnable; }
-    void set_multisampleEnable(bool32_t inValue) { m_struct.multisampleEnable = inValue; }
-    bool32_t get_sampleShadingEnable() { return m_struct.sampleShadingEnable; }
-    void set_sampleShadingEnable(bool32_t inValue) { m_struct.sampleShadingEnable = inValue; }
-    float get_minSampleShading() { return m_struct.minSampleShading; }
-    void set_minSampleShading(float inValue) { m_struct.minSampleShading = inValue; }
-    XGL_SAMPLE_MASK get_sampleMask() { return m_struct.sampleMask; }
-    void set_sampleMask(XGL_SAMPLE_MASK inValue) { m_struct.sampleMask = inValue; }
-
-
-private:
-    XGL_PIPELINE_MS_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_MS_STATE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_barrier_struct_wrapper
-{
-public:
-    xgl_pipeline_barrier_struct_wrapper();
-    xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct);
-    xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct);
-
-    virtual ~xgl_pipeline_barrier_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_eventCount() { return m_struct.eventCount; }
-    void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
-    XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
-    void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
-    uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
-    void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
-
-
-private:
-    XGL_PIPELINE_BARRIER m_struct;
-    const XGL_PIPELINE_BARRIER* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_barrier_struct_wrapper
-{
-public:
-    xgl_memory_barrier_struct_wrapper();
-    xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct);
-    xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct);
-
-    virtual ~xgl_memory_barrier_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
-    void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
-    XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
-    void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
-
-
-private:
-    XGL_MEMORY_BARRIER m_struct;
-    const XGL_MEMORY_BARRIER* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_ia_state_create_info_struct_wrapper
-{
-public:
-    xgl_pipeline_ia_state_create_info_struct_wrapper();
-    xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
-    xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_PRIMITIVE_TOPOLOGY get_topology() { return m_struct.topology; }
-    void set_topology(XGL_PRIMITIVE_TOPOLOGY inValue) { m_struct.topology = inValue; }
-    bool32_t get_disableVertexReuse() { return m_struct.disableVertexReuse; }
-    void set_disableVertexReuse(bool32_t inValue) { m_struct.disableVertexReuse = inValue; }
-    bool32_t get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; }
-    void set_primitiveRestartEnable(bool32_t inValue) { m_struct.primitiveRestartEnable = inValue; }
-    uint32_t get_primitiveRestartIndex() { return m_struct.primitiveRestartIndex; }
-    void set_primitiveRestartIndex(uint32_t inValue) { m_struct.primitiveRestartIndex = inValue; }
-
-
-private:
-    XGL_PIPELINE_IA_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_IA_STATE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_cb_attachment_state_struct_wrapper
-{
-public:
-    xgl_pipeline_cb_attachment_state_struct_wrapper();
-    xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
-    xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
-
-    virtual ~xgl_pipeline_cb_attachment_state_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    bool32_t get_blendEnable() { return m_struct.blendEnable; }
-    void set_blendEnable(bool32_t inValue) { m_struct.blendEnable = inValue; }
-    XGL_FORMAT get_format() { return m_struct.format; }
-    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
-    XGL_BLEND get_srcBlendColor() { return m_struct.srcBlendColor; }
-    void set_srcBlendColor(XGL_BLEND inValue) { m_struct.srcBlendColor = inValue; }
-    XGL_BLEND get_destBlendColor() { return m_struct.destBlendColor; }
-    void set_destBlendColor(XGL_BLEND inValue) { m_struct.destBlendColor = inValue; }
-    XGL_BLEND_FUNC get_blendFuncColor() { return m_struct.blendFuncColor; }
-    void set_blendFuncColor(XGL_BLEND_FUNC inValue) { m_struct.blendFuncColor = inValue; }
-    XGL_BLEND get_srcBlendAlpha() { return m_struct.srcBlendAlpha; }
-    void set_srcBlendAlpha(XGL_BLEND inValue) { m_struct.srcBlendAlpha = inValue; }
-    XGL_BLEND get_destBlendAlpha() { return m_struct.destBlendAlpha; }
-    void set_destBlendAlpha(XGL_BLEND inValue) { m_struct.destBlendAlpha = inValue; }
-    XGL_BLEND_FUNC get_blendFuncAlpha() { return m_struct.blendFuncAlpha; }
-    void set_blendFuncAlpha(XGL_BLEND_FUNC inValue) { m_struct.blendFuncAlpha = inValue; }
-    uint8_t get_channelWriteMask() { return m_struct.channelWriteMask; }
-    void set_channelWriteMask(uint8_t inValue) { m_struct.channelWriteMask = inValue; }
-
-
-private:
-    XGL_PIPELINE_CB_ATTACHMENT_STATE m_struct;
-    const XGL_PIPELINE_CB_ATTACHMENT_STATE* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_cmd_buffer_create_info_struct_wrapper
-{
-public:
-    xgl_cmd_buffer_create_info_struct_wrapper();
-    xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
-    xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_cmd_buffer_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_QUEUE_TYPE get_queueType() { return m_struct.queueType; }
-    void set_queueType(XGL_QUEUE_TYPE inValue) { m_struct.queueType = inValue; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_CMD_BUFFER_CREATE_INFO m_struct;
-    const XGL_CMD_BUFFER_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_application_info_struct_wrapper
-{
-public:
-    xgl_application_info_struct_wrapper();
-    xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct);
-    xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct);
-
-    virtual ~xgl_application_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    const char* get_pAppName() { return m_struct.pAppName; }
-    uint32_t get_appVersion() { return m_struct.appVersion; }
-    void set_appVersion(uint32_t inValue) { m_struct.appVersion = inValue; }
-    const char* get_pEngineName() { return m_struct.pEngineName; }
-    uint32_t get_engineVersion() { return m_struct.engineVersion; }
-    void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; }
-    uint32_t get_apiVersion() { return m_struct.apiVersion; }
-    void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
-
-
-private:
-    XGL_APPLICATION_INFO m_struct;
-    const XGL_APPLICATION_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_rs_state_create_info_struct_wrapper
-{
-public:
-    xgl_pipeline_rs_state_create_info_struct_wrapper();
-    xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
-    xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    bool32_t get_depthClipEnable() { return m_struct.depthClipEnable; }
-    void set_depthClipEnable(bool32_t inValue) { m_struct.depthClipEnable = inValue; }
-    bool32_t get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; }
-    void set_rasterizerDiscardEnable(bool32_t inValue) { m_struct.rasterizerDiscardEnable = inValue; }
-    bool32_t get_programPointSize() { return m_struct.programPointSize; }
-    void set_programPointSize(bool32_t inValue) { m_struct.programPointSize = inValue; }
-    XGL_COORDINATE_ORIGIN get_pointOrigin() { return m_struct.pointOrigin; }
-    void set_pointOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.pointOrigin = inValue; }
-    XGL_PROVOKING_VERTEX_CONVENTION get_provokingVertex() { return m_struct.provokingVertex; }
-    void set_provokingVertex(XGL_PROVOKING_VERTEX_CONVENTION inValue) { m_struct.provokingVertex = inValue; }
-    XGL_FILL_MODE get_fillMode() { return m_struct.fillMode; }
-    void set_fillMode(XGL_FILL_MODE inValue) { m_struct.fillMode = inValue; }
-    XGL_CULL_MODE get_cullMode() { return m_struct.cullMode; }
-    void set_cullMode(XGL_CULL_MODE inValue) { m_struct.cullMode = inValue; }
-    XGL_FACE_ORIENTATION get_frontFace() { return m_struct.frontFace; }
-    void set_frontFace(XGL_FACE_ORIENTATION inValue) { m_struct.frontFace = inValue; }
-
-
-private:
-    XGL_PIPELINE_RS_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_RS_STATE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_color_attachment_view_create_info_struct_wrapper
-{
-public:
-    xgl_color_attachment_view_create_info_struct_wrapper();
-    xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
-    xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_color_attachment_view_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_IMAGE get_image() { return m_struct.image; }
-    void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
-    XGL_FORMAT get_format() { return m_struct.format; }
-    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
-    uint32_t get_mipLevel() { return m_struct.mipLevel; }
-    void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
-    uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
-    void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
-    uint32_t get_arraySize() { return m_struct.arraySize; }
-    void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
-    XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
-    void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
-    XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
-    void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
-
-
-private:
-    XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct;
-    const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_memory_bind_info_struct_wrapper
-{
-public:
-    xgl_image_memory_bind_info_struct_wrapper();
-    xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
-    xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
-
-    virtual ~xgl_image_memory_bind_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_IMAGE_SUBRESOURCE get_subresource() { return m_struct.subresource; }
-    void set_subresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.subresource = inValue; }
-    XGL_OFFSET3D get_offset() { return m_struct.offset; }
-    void set_offset(XGL_OFFSET3D inValue) { m_struct.offset = inValue; }
-    XGL_EXTENT3D get_extent() { return m_struct.extent; }
-    void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
-
-
-private:
-    XGL_IMAGE_MEMORY_BIND_INFO m_struct;
-    const XGL_IMAGE_MEMORY_BIND_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
 class xgl_image_subresource_struct_wrapper
 {
 public:
@@ -1677,49 +3259,14 @@
 
 
 //class declaration
-class xgl_draw_indirect_cmd_struct_wrapper
+class xgl_layer_create_info_struct_wrapper
 {
 public:
-    xgl_draw_indirect_cmd_struct_wrapper();
-    xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct);
-    xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct);
+    xgl_layer_create_info_struct_wrapper();
+    xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct);
+    xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct);
 
-    virtual ~xgl_draw_indirect_cmd_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    uint32_t get_vertexCount() { return m_struct.vertexCount; }
-    void set_vertexCount(uint32_t inValue) { m_struct.vertexCount = inValue; }
-    uint32_t get_instanceCount() { return m_struct.instanceCount; }
-    void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
-    uint32_t get_firstVertex() { return m_struct.firstVertex; }
-    void set_firstVertex(uint32_t inValue) { m_struct.firstVertex = inValue; }
-    uint32_t get_firstInstance() { return m_struct.firstInstance; }
-    void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
-
-
-private:
-    XGL_DRAW_INDIRECT_CMD m_struct;
-    const XGL_DRAW_INDIRECT_CMD* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_view_create_info_struct_wrapper
-{
-public:
-    xgl_image_view_create_info_struct_wrapper();
-    xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
-    xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_image_view_create_info_struct_wrapper();
+    virtual ~xgl_layer_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1729,92 +3276,13 @@
     XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
     void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
     const void* get_pNext() { return m_struct.pNext; }
-    XGL_IMAGE get_image() { return m_struct.image; }
-    void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
-    XGL_IMAGE_VIEW_TYPE get_viewType() { return m_struct.viewType; }
-    void set_viewType(XGL_IMAGE_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
-    XGL_FORMAT get_format() { return m_struct.format; }
-    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
-    XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
-    void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
-    XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
-    void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
-    float get_minLod() { return m_struct.minLod; }
-    void set_minLod(float inValue) { m_struct.minLod = inValue; }
+    uint32_t get_layerCount() { return m_struct.layerCount; }
+    void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; }
 
 
 private:
-    XGL_IMAGE_VIEW_CREATE_INFO m_struct;
-    const XGL_IMAGE_VIEW_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_cmd_buffer_begin_info_struct_wrapper
-{
-public:
-    xgl_cmd_buffer_begin_info_struct_wrapper();
-    xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
-    xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
-
-    virtual ~xgl_cmd_buffer_begin_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_CMD_BUFFER_BEGIN_INFO m_struct;
-    const XGL_CMD_BUFFER_BEGIN_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_copy_struct_wrapper
-{
-public:
-    xgl_image_copy_struct_wrapper();
-    xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct);
-    xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct);
-
-    virtual ~xgl_image_copy_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
-    void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
-    XGL_OFFSET3D get_srcOffset() { return m_struct.srcOffset; }
-    void set_srcOffset(XGL_OFFSET3D inValue) { m_struct.srcOffset = inValue; }
-    XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
-    void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
-    XGL_OFFSET3D get_destOffset() { return m_struct.destOffset; }
-    void set_destOffset(XGL_OFFSET3D inValue) { m_struct.destOffset = inValue; }
-    XGL_EXTENT3D get_extent() { return m_struct.extent; }
-    void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
-
-
-private:
-    XGL_IMAGE_COPY m_struct;
-    const XGL_IMAGE_COPY* m_origStructAddr;
+    XGL_LAYER_CREATE_INFO m_struct;
+    const XGL_LAYER_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1859,14 +3327,14 @@
 
 
 //class declaration
-class xgl_image_memory_barrier_struct_wrapper
+class xgl_buffer_create_info_struct_wrapper
 {
 public:
-    xgl_image_memory_barrier_struct_wrapper();
-    xgl_image_memory_barrier_struct_wrapper(XGL_IMAGE_MEMORY_BARRIER* pInStruct);
-    xgl_image_memory_barrier_struct_wrapper(const XGL_IMAGE_MEMORY_BARRIER* pInStruct);
+    xgl_buffer_create_info_struct_wrapper();
+    xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct);
+    xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct);
 
-    virtual ~xgl_image_memory_barrier_struct_wrapper();
+    virtual ~xgl_buffer_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1876,261 +3344,17 @@
     XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
     void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
     const void* get_pNext() { return m_struct.pNext; }
-    XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
-    void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
-    XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
-    void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
-    XGL_IMAGE_LAYOUT get_oldLayout() { return m_struct.oldLayout; }
-    void set_oldLayout(XGL_IMAGE_LAYOUT inValue) { m_struct.oldLayout = inValue; }
-    XGL_IMAGE_LAYOUT get_newLayout() { return m_struct.newLayout; }
-    void set_newLayout(XGL_IMAGE_LAYOUT inValue) { m_struct.newLayout = inValue; }
-    XGL_IMAGE get_image() { return m_struct.image; }
-    void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
-    XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
-    void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
-
-
-private:
-    XGL_IMAGE_MEMORY_BARRIER m_struct;
-    const XGL_IMAGE_MEMORY_BARRIER* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_physical_gpu_memory_properties_struct_wrapper
-{
-public:
-    xgl_physical_gpu_memory_properties_struct_wrapper();
-    xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
-    xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
-
-    virtual ~xgl_physical_gpu_memory_properties_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    bool32_t get_supportsMigration() { return m_struct.supportsMigration; }
-    void set_supportsMigration(bool32_t inValue) { m_struct.supportsMigration = inValue; }
-    bool32_t get_supportsPinning() { return m_struct.supportsPinning; }
-    void set_supportsPinning(bool32_t inValue) { m_struct.supportsPinning = inValue; }
-
-
-private:
-    XGL_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct;
-    const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_alloc_buffer_info_struct_wrapper
-{
-public:
-    xgl_memory_alloc_buffer_info_struct_wrapper();
-    xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
-    xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
-
-    virtual ~xgl_memory_alloc_buffer_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
+    XGL_GPU_SIZE get_size() { return m_struct.size; }
+    void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
     XGL_FLAGS get_usage() { return m_struct.usage; }
     void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
-
-
-private:
-    XGL_MEMORY_ALLOC_BUFFER_INFO m_struct;
-    const XGL_MEMORY_ALLOC_BUFFER_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_compute_pipeline_create_info_struct_wrapper
-{
-public:
-    xgl_compute_pipeline_create_info_struct_wrapper();
-    xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
-    xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_compute_pipeline_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_PIPELINE_SHADER get_cs() { return m_struct.cs; }
-    void set_cs(XGL_PIPELINE_SHADER inValue) { m_struct.cs = inValue; }
     XGL_FLAGS get_flags() { return m_struct.flags; }
     void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-    XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
-    void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
-    uint32_t get_localSizeX() { return m_struct.localSizeX; }
-    void set_localSizeX(uint32_t inValue) { m_struct.localSizeX = inValue; }
-    uint32_t get_localSizeY() { return m_struct.localSizeY; }
-    void set_localSizeY(uint32_t inValue) { m_struct.localSizeY = inValue; }
-    uint32_t get_localSizeZ() { return m_struct.localSizeZ; }
-    void set_localSizeZ(uint32_t inValue) { m_struct.localSizeZ = inValue; }
 
 
 private:
-    XGL_COMPUTE_PIPELINE_CREATE_INFO m_struct;
-    const XGL_COMPUTE_PIPELINE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_channel_mapping_struct_wrapper
-{
-public:
-    xgl_channel_mapping_struct_wrapper();
-    xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct);
-    xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct);
-
-    virtual ~xgl_channel_mapping_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_CHANNEL_SWIZZLE get_r() { return m_struct.r; }
-    void set_r(XGL_CHANNEL_SWIZZLE inValue) { m_struct.r = inValue; }
-    XGL_CHANNEL_SWIZZLE get_g() { return m_struct.g; }
-    void set_g(XGL_CHANNEL_SWIZZLE inValue) { m_struct.g = inValue; }
-    XGL_CHANNEL_SWIZZLE get_b() { return m_struct.b; }
-    void set_b(XGL_CHANNEL_SWIZZLE inValue) { m_struct.b = inValue; }
-    XGL_CHANNEL_SWIZZLE get_a() { return m_struct.a; }
-    void set_a(XGL_CHANNEL_SWIZZLE inValue) { m_struct.a = inValue; }
-
-
-private:
-    XGL_CHANNEL_MAPPING m_struct;
-    const XGL_CHANNEL_MAPPING* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_peer_image_open_info_struct_wrapper
-{
-public:
-    xgl_peer_image_open_info_struct_wrapper();
-    xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
-    xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
-
-    virtual ~xgl_peer_image_open_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_IMAGE get_originalImage() { return m_struct.originalImage; }
-    void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; }
-
-
-private:
-    XGL_PEER_IMAGE_OPEN_INFO m_struct;
-    const XGL_PEER_IMAGE_OPEN_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dynamic_vp_state_create_info_struct_wrapper
-{
-public:
-    xgl_dynamic_vp_state_create_info_struct_wrapper();
-    xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
-    xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_dynamic_vp_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_viewportAndScissorCount() { return m_struct.viewportAndScissorCount; }
-    void set_viewportAndScissorCount(uint32_t inValue) { m_struct.viewportAndScissorCount = inValue; }
-
-
-private:
-    XGL_DYNAMIC_VP_STATE_CREATE_INFO m_struct;
-    const XGL_DYNAMIC_VP_STATE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_physical_gpu_performance_struct_wrapper
-{
-public:
-    xgl_physical_gpu_performance_struct_wrapper();
-    xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
-    xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
-
-    virtual ~xgl_physical_gpu_performance_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    float get_maxGpuClock() { return m_struct.maxGpuClock; }
-    void set_maxGpuClock(float inValue) { m_struct.maxGpuClock = inValue; }
-    float get_aluPerClock() { return m_struct.aluPerClock; }
-    void set_aluPerClock(float inValue) { m_struct.aluPerClock = inValue; }
-    float get_texPerClock() { return m_struct.texPerClock; }
-    void set_texPerClock(float inValue) { m_struct.texPerClock = inValue; }
-    float get_primsPerClock() { return m_struct.primsPerClock; }
-    void set_primsPerClock(float inValue) { m_struct.primsPerClock = inValue; }
-    float get_pixelsPerClock() { return m_struct.pixelsPerClock; }
-    void set_pixelsPerClock(float inValue) { m_struct.pixelsPerClock = inValue; }
-
-
-private:
-    XGL_PHYSICAL_GPU_PERFORMANCE m_struct;
-    const XGL_PHYSICAL_GPU_PERFORMANCE* m_origStructAddr;
+    XGL_BUFFER_CREATE_INFO m_struct;
+    const XGL_BUFFER_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2187,442 +3411,14 @@
 
 
 //class declaration
-class xgl_viewport_struct_wrapper
+class xgl_descriptor_set_layout_create_info_struct_wrapper
 {
 public:
-    xgl_viewport_struct_wrapper();
-    xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct);
-    xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct);
+    xgl_descriptor_set_layout_create_info_struct_wrapper();
+    xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
+    xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
 
-    virtual ~xgl_viewport_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    float get_originX() { return m_struct.originX; }
-    void set_originX(float inValue) { m_struct.originX = inValue; }
-    float get_originY() { return m_struct.originY; }
-    void set_originY(float inValue) { m_struct.originY = inValue; }
-    float get_width() { return m_struct.width; }
-    void set_width(float inValue) { m_struct.width = inValue; }
-    float get_height() { return m_struct.height; }
-    void set_height(float inValue) { m_struct.height = inValue; }
-    float get_minDepth() { return m_struct.minDepth; }
-    void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
-    float get_maxDepth() { return m_struct.maxDepth; }
-    void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
-
-
-private:
-    XGL_VIEWPORT m_struct;
-    const XGL_VIEWPORT* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dynamic_ds_state_create_info_struct_wrapper
-{
-public:
-    xgl_dynamic_ds_state_create_info_struct_wrapper();
-    xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
-    xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_dynamic_ds_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    float get_minDepth() { return m_struct.minDepth; }
-    void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
-    float get_maxDepth() { return m_struct.maxDepth; }
-    void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
-    uint32_t get_stencilReadMask() { return m_struct.stencilReadMask; }
-    void set_stencilReadMask(uint32_t inValue) { m_struct.stencilReadMask = inValue; }
-    uint32_t get_stencilWriteMask() { return m_struct.stencilWriteMask; }
-    void set_stencilWriteMask(uint32_t inValue) { m_struct.stencilWriteMask = inValue; }
-    uint32_t get_stencilFrontRef() { return m_struct.stencilFrontRef; }
-    void set_stencilFrontRef(uint32_t inValue) { m_struct.stencilFrontRef = inValue; }
-    uint32_t get_stencilBackRef() { return m_struct.stencilBackRef; }
-    void set_stencilBackRef(uint32_t inValue) { m_struct.stencilBackRef = inValue; }
-
-
-private:
-    XGL_DYNAMIC_DS_STATE_CREATE_INFO m_struct;
-    const XGL_DYNAMIC_DS_STATE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_create_info_struct_wrapper
-{
-public:
-    xgl_buffer_create_info_struct_wrapper();
-    xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct);
-    xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_buffer_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_GPU_SIZE get_size() { return m_struct.size; }
-    void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
-    XGL_FLAGS get_usage() { return m_struct.usage; }
-    void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_BUFFER_CREATE_INFO m_struct;
-    const XGL_BUFFER_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_cmd_buffer_graphics_begin_info_struct_wrapper
-{
-public:
-    xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
-    xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
-    xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
-
-    virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_RENDER_PASS get_renderPass() { return m_struct.renderPass; }
-    void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = inValue; }
-
-
-private:
-    XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO m_struct;
-    const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_rect_struct_wrapper
-{
-public:
-    xgl_rect_struct_wrapper();
-    xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
-    xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
-
-    virtual ~xgl_rect_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_OFFSET2D get_offset() { return m_struct.offset; }
-    void set_offset(XGL_OFFSET2D inValue) { m_struct.offset = inValue; }
-    XGL_EXTENT2D get_extent() { return m_struct.extent; }
-    void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
-
-
-private:
-    XGL_RECT m_struct;
-    const XGL_RECT* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_memory_barrier_struct_wrapper
-{
-public:
-    xgl_buffer_memory_barrier_struct_wrapper();
-    xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct);
-    xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct);
-
-    virtual ~xgl_buffer_memory_barrier_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
-    void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
-    XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
-    void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
-    XGL_BUFFER get_buffer() { return m_struct.buffer; }
-    void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
-    XGL_GPU_SIZE get_offset() { return m_struct.offset; }
-    void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
-    XGL_GPU_SIZE get_size() { return m_struct.size; }
-    void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
-
-
-private:
-    XGL_BUFFER_MEMORY_BARRIER m_struct;
-    const XGL_BUFFER_MEMORY_BARRIER* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_ds_state_create_info_struct_wrapper
-{
-public:
-    xgl_pipeline_ds_state_create_info_struct_wrapper();
-    xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
-    xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_pipeline_ds_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_FORMAT get_format() { return m_struct.format; }
-    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
-    bool32_t get_depthTestEnable() { return m_struct.depthTestEnable; }
-    void set_depthTestEnable(bool32_t inValue) { m_struct.depthTestEnable = inValue; }
-    bool32_t get_depthWriteEnable() { return m_struct.depthWriteEnable; }
-    void set_depthWriteEnable(bool32_t inValue) { m_struct.depthWriteEnable = inValue; }
-    XGL_COMPARE_FUNC get_depthFunc() { return m_struct.depthFunc; }
-    void set_depthFunc(XGL_COMPARE_FUNC inValue) { m_struct.depthFunc = inValue; }
-    bool32_t get_depthBoundsEnable() { return m_struct.depthBoundsEnable; }
-    void set_depthBoundsEnable(bool32_t inValue) { m_struct.depthBoundsEnable = inValue; }
-    bool32_t get_stencilTestEnable() { return m_struct.stencilTestEnable; }
-    void set_stencilTestEnable(bool32_t inValue) { m_struct.stencilTestEnable = inValue; }
-    XGL_STENCIL_OP_STATE get_front() { return m_struct.front; }
-    void set_front(XGL_STENCIL_OP_STATE inValue) { m_struct.front = inValue; }
-    XGL_STENCIL_OP_STATE get_back() { return m_struct.back; }
-    void set_back(XGL_STENCIL_OP_STATE inValue) { m_struct.back = inValue; }
-
-
-private:
-    XGL_PIPELINE_DS_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_DS_STATE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_descriptor_type_count_struct_wrapper
-{
-public:
-    xgl_descriptor_type_count_struct_wrapper();
-    xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
-    xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
-
-    virtual ~xgl_descriptor_type_count_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_DESCRIPTOR_TYPE get_type() { return m_struct.type; }
-    void set_type(XGL_DESCRIPTOR_TYPE inValue) { m_struct.type = inValue; }
-    uint32_t get_count() { return m_struct.count; }
-    void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
-    XGL_DESCRIPTOR_TYPE_COUNT m_struct;
-    const XGL_DESCRIPTOR_TYPE_COUNT* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_sampler_textures_struct_wrapper
-{
-public:
-    xgl_update_sampler_textures_struct_wrapper();
-    xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
-    xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
-
-    virtual ~xgl_update_sampler_textures_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_index() { return m_struct.index; }
-    void set_index(uint32_t inValue) { m_struct.index = inValue; }
-    uint32_t get_count() { return m_struct.count; }
-    void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
-    XGL_UPDATE_SAMPLER_TEXTURES m_struct;
-    const XGL_UPDATE_SAMPLER_TEXTURES* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_query_pool_create_info_struct_wrapper
-{
-public:
-    xgl_query_pool_create_info_struct_wrapper();
-    xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct);
-    xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_query_pool_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_QUERY_TYPE get_queryType() { return m_struct.queryType; }
-    void set_queryType(XGL_QUERY_TYPE inValue) { m_struct.queryType = inValue; }
-    uint32_t get_slots() { return m_struct.slots; }
-    void set_slots(uint32_t inValue) { m_struct.slots = inValue; }
-
-
-private:
-    XGL_QUERY_POOL_CREATE_INFO m_struct;
-    const XGL_QUERY_POOL_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_event_create_info_struct_wrapper
-{
-public:
-    xgl_event_create_info_struct_wrapper();
-    xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct);
-    xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_event_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_EVENT_CREATE_INFO m_struct;
-    const XGL_EVENT_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_offset2d_struct_wrapper
-{
-public:
-    xgl_offset2d_struct_wrapper();
-    xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
-    xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
-
-    virtual ~xgl_offset2d_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    int32_t get_x() { return m_struct.x; }
-    void set_x(int32_t inValue) { m_struct.x = inValue; }
-    int32_t get_y() { return m_struct.y; }
-    void set_y(int32_t inValue) { m_struct.y = inValue; }
-
-
-private:
-    XGL_OFFSET2D m_struct;
-    const XGL_OFFSET2D* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_buffers_struct_wrapper
-{
-public:
-    xgl_update_buffers_struct_wrapper();
-    xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct);
-    xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct);
-
-    virtual ~xgl_update_buffers_struct_wrapper();
+    virtual ~xgl_descriptor_set_layout_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2634,112 +3430,17 @@
     const void* get_pNext() { return m_struct.pNext; }
     XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
     void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
-    uint32_t get_index() { return m_struct.index; }
-    void set_index(uint32_t inValue) { m_struct.index = inValue; }
     uint32_t get_count() { return m_struct.count; }
     void set_count(uint32_t inValue) { m_struct.count = inValue; }
+    XGL_FLAGS get_stageFlags() { return m_struct.stageFlags; }
+    void set_stageFlags(XGL_FLAGS inValue) { m_struct.stageFlags = inValue; }
+    XGL_SAMPLER get_immutableSampler() { return m_struct.immutableSampler; }
+    void set_immutableSampler(XGL_SAMPLER inValue) { m_struct.immutableSampler = inValue; }
 
 
 private:
-    XGL_UPDATE_BUFFERS m_struct;
-    const XGL_UPDATE_BUFFERS* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_ref_struct_wrapper
-{
-public:
-    xgl_memory_ref_struct_wrapper();
-    xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct);
-    xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct);
-
-    virtual ~xgl_memory_ref_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
-    void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_MEMORY_REF m_struct;
-    const XGL_MEMORY_REF* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_view_attach_info_struct_wrapper
-{
-public:
-    xgl_buffer_view_attach_info_struct_wrapper();
-    xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
-    xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
-
-    virtual ~xgl_buffer_view_attach_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_BUFFER_VIEW get_view() { return m_struct.view; }
-    void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; }
-
-
-private:
-    XGL_BUFFER_VIEW_ATTACH_INFO m_struct;
-    const XGL_BUFFER_VIEW_ATTACH_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_vertex_input_create_info_struct_wrapper
-{
-public:
-    xgl_pipeline_vertex_input_create_info_struct_wrapper();
-    xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
-    xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_pipeline_vertex_input_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_bindingCount() { return m_struct.bindingCount; }
-    void set_bindingCount(uint32_t inValue) { m_struct.bindingCount = inValue; }
-    uint32_t get_attributeCount() { return m_struct.attributeCount; }
-    void set_attributeCount(uint32_t inValue) { m_struct.attributeCount = inValue; }
-
-
-private:
-    XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_struct;
-    const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* m_origStructAddr;
+    XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO m_struct;
+    const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2777,14 +3478,14 @@
 
 
 //class declaration
-class xgl_shader_create_info_struct_wrapper
+class xgl_memory_alloc_info_struct_wrapper
 {
 public:
-    xgl_shader_create_info_struct_wrapper();
-    xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct);
-    xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct);
+    xgl_memory_alloc_info_struct_wrapper();
+    xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct);
+    xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct);
 
-    virtual ~xgl_shader_create_info_struct_wrapper();
+    virtual ~xgl_memory_alloc_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2794,16 +3495,19 @@
     XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
     void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
     const void* get_pNext() { return m_struct.pNext; }
-    size_t get_codeSize() { return m_struct.codeSize; }
-    void set_codeSize(size_t inValue) { m_struct.codeSize = inValue; }
-    const void* get_pCode() { return m_struct.pCode; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+    XGL_GPU_SIZE get_allocationSize() { return m_struct.allocationSize; }
+    void set_allocationSize(XGL_GPU_SIZE inValue) { m_struct.allocationSize = inValue; }
+    XGL_FLAGS get_memProps() { return m_struct.memProps; }
+    void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
+    XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
+    void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
+    XGL_MEMORY_PRIORITY get_memPriority() { return m_struct.memPriority; }
+    void set_memPriority(XGL_MEMORY_PRIORITY inValue) { m_struct.memPriority = inValue; }
 
 
 private:
-    XGL_SHADER_CREATE_INFO m_struct;
-    const XGL_SHADER_CREATE_INFO* m_origStructAddr;
+    XGL_MEMORY_ALLOC_INFO m_struct;
+    const XGL_MEMORY_ALLOC_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2812,737 +3516,33 @@
 
 
 //class declaration
-class xgl_offset3d_struct_wrapper
+class xgl_physical_gpu_queue_properties_struct_wrapper
 {
 public:
-    xgl_offset3d_struct_wrapper();
-    xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
-    xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
+    xgl_physical_gpu_queue_properties_struct_wrapper();
+    xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
+    xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
 
-    virtual ~xgl_offset3d_struct_wrapper();
+    virtual ~xgl_physical_gpu_queue_properties_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
     void display_full_txt();
 
     void set_indent(uint32_t indent) { m_indent = indent; }
-    int32_t get_x() { return m_struct.x; }
-    void set_x(int32_t inValue) { m_struct.x = inValue; }
-    int32_t get_y() { return m_struct.y; }
-    void set_y(int32_t inValue) { m_struct.y = inValue; }
-    int32_t get_z() { return m_struct.z; }
-    void set_z(int32_t inValue) { m_struct.z = inValue; }
-
-
-private:
-    XGL_OFFSET3D m_struct;
-    const XGL_OFFSET3D* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_layer_create_info_struct_wrapper
-{
-public:
-    xgl_layer_create_info_struct_wrapper();
-    xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct);
-    xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_layer_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_layerCount() { return m_struct.layerCount; }
-    void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; }
-
-
-private:
-    XGL_LAYER_CREATE_INFO m_struct;
-    const XGL_LAYER_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_depth_stencil_view_create_info_struct_wrapper
-{
-public:
-    xgl_depth_stencil_view_create_info_struct_wrapper();
-    xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
-    xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_IMAGE get_image() { return m_struct.image; }
-    void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
-    uint32_t get_mipLevel() { return m_struct.mipLevel; }
-    void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
-    uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
-    void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
-    uint32_t get_arraySize() { return m_struct.arraySize; }
-    void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
-    XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
-    void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
-    XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
-    void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct;
-    const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_depth_stencil_bind_info_struct_wrapper
-{
-public:
-    xgl_depth_stencil_bind_info_struct_wrapper();
-    xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
-    xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
-
-    virtual ~xgl_depth_stencil_bind_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_DEPTH_STENCIL_VIEW get_view() { return m_struct.view; }
-    void set_view(XGL_DEPTH_STENCIL_VIEW inValue) { m_struct.view = inValue; }
-    XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
-    void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
-
-
-private:
-    XGL_DEPTH_STENCIL_BIND_INFO m_struct;
-    const XGL_DEPTH_STENCIL_BIND_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_memory_requirements_struct_wrapper
-{
-public:
-    xgl_image_memory_requirements_struct_wrapper();
-    xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct);
-    xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct);
-
-    virtual ~xgl_image_memory_requirements_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_FLAGS get_usage() { return m_struct.usage; }
-    void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
-    XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
-    void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
-    uint32_t get_samples() { return m_struct.samples; }
-    void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
-
-
-private:
-    XGL_IMAGE_MEMORY_REQUIREMENTS m_struct;
-    const XGL_IMAGE_MEMORY_REQUIREMENTS* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_subresource_range_struct_wrapper
-{
-public:
-    xgl_image_subresource_range_struct_wrapper();
-    xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
-    xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
-
-    virtual ~xgl_image_subresource_range_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
-    void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
-    uint32_t get_baseMipLevel() { return m_struct.baseMipLevel; }
-    void set_baseMipLevel(uint32_t inValue) { m_struct.baseMipLevel = inValue; }
-    uint32_t get_mipLevels() { return m_struct.mipLevels; }
-    void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
-    uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
-    void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
-    uint32_t get_arraySize() { return m_struct.arraySize; }
-    void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
-
-
-private:
-    XGL_IMAGE_SUBRESOURCE_RANGE m_struct;
-    const XGL_IMAGE_SUBRESOURCE_RANGE* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_images_struct_wrapper
-{
-public:
-    xgl_update_images_struct_wrapper();
-    xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct);
-    xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct);
-
-    virtual ~xgl_update_images_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
-    void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
-    uint32_t get_index() { return m_struct.index; }
-    void set_index(uint32_t inValue) { m_struct.index = inValue; }
-    uint32_t get_count() { return m_struct.count; }
-    void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
-    XGL_UPDATE_IMAGES m_struct;
-    const XGL_UPDATE_IMAGES* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dispatch_indirect_cmd_struct_wrapper
-{
-public:
-    xgl_dispatch_indirect_cmd_struct_wrapper();
-    xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct);
-    xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct);
-
-    virtual ~xgl_dispatch_indirect_cmd_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    uint32_t get_x() { return m_struct.x; }
-    void set_x(uint32_t inValue) { m_struct.x = inValue; }
-    uint32_t get_y() { return m_struct.y; }
-    void set_y(uint32_t inValue) { m_struct.y = inValue; }
-    uint32_t get_z() { return m_struct.z; }
-    void set_z(uint32_t inValue) { m_struct.z = inValue; }
-
-
-private:
-    XGL_DISPATCH_INDIRECT_CMD m_struct;
-    const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_extent3d_struct_wrapper
-{
-public:
-    xgl_extent3d_struct_wrapper();
-    xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct);
-    xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct);
-
-    virtual ~xgl_extent3d_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    int32_t get_width() { return m_struct.width; }
-    void set_width(int32_t inValue) { m_struct.width = inValue; }
-    int32_t get_height() { return m_struct.height; }
-    void set_height(int32_t inValue) { m_struct.height = inValue; }
-    int32_t get_depth() { return m_struct.depth; }
-    void set_depth(int32_t inValue) { m_struct.depth = inValue; }
-
-
-private:
-    XGL_EXTENT3D m_struct;
-    const XGL_EXTENT3D* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_clear_color_value_struct_wrapper
-{
-public:
-    xgl_clear_color_value_struct_wrapper();
-    xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct);
-    xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct);
-
-    virtual ~xgl_clear_color_value_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-
-
-private:
-    XGL_CLEAR_COLOR_VALUE m_struct;
-    const XGL_CLEAR_COLOR_VALUE* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_alloc_image_info_struct_wrapper
-{
-public:
-    xgl_memory_alloc_image_info_struct_wrapper();
-    xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
-    xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
-
-    virtual ~xgl_memory_alloc_image_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_FLAGS get_usage() { return m_struct.usage; }
-    void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
-    XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
-    void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
-    uint32_t get_samples() { return m_struct.samples; }
-    void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
-
-
-private:
-    XGL_MEMORY_ALLOC_IMAGE_INFO m_struct;
-    const XGL_MEMORY_ALLOC_IMAGE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_device_queue_create_info_struct_wrapper
-{
-public:
-    xgl_device_queue_create_info_struct_wrapper();
-    xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
-    xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_device_queue_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    uint32_t get_queueNodeIndex() { return m_struct.queueNodeIndex; }
-    void set_queueNodeIndex(uint32_t inValue) { m_struct.queueNodeIndex = inValue; }
+    XGL_FLAGS get_queueFlags() { return m_struct.queueFlags; }
+    void set_queueFlags(XGL_FLAGS inValue) { m_struct.queueFlags = inValue; }
     uint32_t get_queueCount() { return m_struct.queueCount; }
     void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
+    uint32_t get_maxAtomicCounters() { return m_struct.maxAtomicCounters; }
+    void set_maxAtomicCounters(uint32_t inValue) { m_struct.maxAtomicCounters = inValue; }
+    bool32_t get_supportsTimestamps() { return m_struct.supportsTimestamps; }
+    void set_supportsTimestamps(bool32_t inValue) { m_struct.supportsTimestamps = inValue; }
 
 
 private:
-    XGL_DEVICE_QUEUE_CREATE_INFO m_struct;
-    const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_stencil_op_state_struct_wrapper
-{
-public:
-    xgl_stencil_op_state_struct_wrapper();
-    xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct);
-    xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct);
-
-    virtual ~xgl_stencil_op_state_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STENCIL_OP get_stencilFailOp() { return m_struct.stencilFailOp; }
-    void set_stencilFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilFailOp = inValue; }
-    XGL_STENCIL_OP get_stencilPassOp() { return m_struct.stencilPassOp; }
-    void set_stencilPassOp(XGL_STENCIL_OP inValue) { m_struct.stencilPassOp = inValue; }
-    XGL_STENCIL_OP get_stencilDepthFailOp() { return m_struct.stencilDepthFailOp; }
-    void set_stencilDepthFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilDepthFailOp = inValue; }
-    XGL_COMPARE_FUNC get_stencilFunc() { return m_struct.stencilFunc; }
-    void set_stencilFunc(XGL_COMPARE_FUNC inValue) { m_struct.stencilFunc = inValue; }
-
-
-private:
-    XGL_STENCIL_OP_STATE m_struct;
-    const XGL_STENCIL_OP_STATE* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_shader_struct_wrapper
-{
-public:
-    xgl_pipeline_shader_struct_wrapper();
-    xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct);
-    xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct);
-
-    virtual ~xgl_pipeline_shader_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_PIPELINE_SHADER_STAGE get_stage() { return m_struct.stage; }
-    void set_stage(XGL_PIPELINE_SHADER_STAGE inValue) { m_struct.stage = inValue; }
-    XGL_SHADER get_shader() { return m_struct.shader; }
-    void set_shader(XGL_SHADER inValue) { m_struct.shader = inValue; }
-    uint32_t get_linkConstBufferCount() { return m_struct.linkConstBufferCount; }
-    void set_linkConstBufferCount(uint32_t inValue) { m_struct.linkConstBufferCount = inValue; }
-
-
-private:
-    XGL_PIPELINE_SHADER m_struct;
-    const XGL_PIPELINE_SHADER* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_queue_semaphore_create_info_struct_wrapper
-{
-public:
-    xgl_queue_semaphore_create_info_struct_wrapper();
-    xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
-    xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_queue_semaphore_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_initialCount() { return m_struct.initialCount; }
-    void set_initialCount(uint32_t inValue) { m_struct.initialCount = inValue; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_QUEUE_SEMAPHORE_CREATE_INFO m_struct;
-    const XGL_QUEUE_SEMAPHORE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_statistics_data_struct_wrapper
-{
-public:
-    xgl_pipeline_statistics_data_struct_wrapper();
-    xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct);
-    xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct);
-
-    virtual ~xgl_pipeline_statistics_data_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    uint64_t get_fsInvocations() { return m_struct.fsInvocations; }
-    void set_fsInvocations(uint64_t inValue) { m_struct.fsInvocations = inValue; }
-    uint64_t get_cPrimitives() { return m_struct.cPrimitives; }
-    void set_cPrimitives(uint64_t inValue) { m_struct.cPrimitives = inValue; }
-    uint64_t get_cInvocations() { return m_struct.cInvocations; }
-    void set_cInvocations(uint64_t inValue) { m_struct.cInvocations = inValue; }
-    uint64_t get_vsInvocations() { return m_struct.vsInvocations; }
-    void set_vsInvocations(uint64_t inValue) { m_struct.vsInvocations = inValue; }
-    uint64_t get_gsInvocations() { return m_struct.gsInvocations; }
-    void set_gsInvocations(uint64_t inValue) { m_struct.gsInvocations = inValue; }
-    uint64_t get_gsPrimitives() { return m_struct.gsPrimitives; }
-    void set_gsPrimitives(uint64_t inValue) { m_struct.gsPrimitives = inValue; }
-    uint64_t get_iaPrimitives() { return m_struct.iaPrimitives; }
-    void set_iaPrimitives(uint64_t inValue) { m_struct.iaPrimitives = inValue; }
-    uint64_t get_iaVertices() { return m_struct.iaVertices; }
-    void set_iaVertices(uint64_t inValue) { m_struct.iaVertices = inValue; }
-    uint64_t get_tcsInvocations() { return m_struct.tcsInvocations; }
-    void set_tcsInvocations(uint64_t inValue) { m_struct.tcsInvocations = inValue; }
-    uint64_t get_tesInvocations() { return m_struct.tesInvocations; }
-    void set_tesInvocations(uint64_t inValue) { m_struct.tesInvocations = inValue; }
-    uint64_t get_csInvocations() { return m_struct.csInvocations; }
-    void set_csInvocations(uint64_t inValue) { m_struct.csInvocations = inValue; }
-
-
-private:
-    XGL_PIPELINE_STATISTICS_DATA m_struct;
-    const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_vertex_input_attribute_description_struct_wrapper
-{
-public:
-    xgl_vertex_input_attribute_description_struct_wrapper();
-    xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
-    xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
-
-    virtual ~xgl_vertex_input_attribute_description_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    uint32_t get_binding() { return m_struct.binding; }
-    void set_binding(uint32_t inValue) { m_struct.binding = inValue; }
-    XGL_FORMAT get_format() { return m_struct.format; }
-    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
-    uint32_t get_offsetInBytes() { return m_struct.offsetInBytes; }
-    void set_offsetInBytes(uint32_t inValue) { m_struct.offsetInBytes = inValue; }
-
-
-private:
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION m_struct;
-    const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_vertex_input_binding_description_struct_wrapper
-{
-public:
-    xgl_vertex_input_binding_description_struct_wrapper();
-    xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
-    xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
-
-    virtual ~xgl_vertex_input_binding_description_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    uint32_t get_strideInBytes() { return m_struct.strideInBytes; }
-    void set_strideInBytes(uint32_t inValue) { m_struct.strideInBytes = inValue; }
-    XGL_VERTEX_INPUT_STEP_RATE get_stepRate() { return m_struct.stepRate; }
-    void set_stepRate(XGL_VERTEX_INPUT_STEP_RATE inValue) { m_struct.stepRate = inValue; }
-
-
-private:
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION m_struct;
-    const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_samplers_struct_wrapper
-{
-public:
-    xgl_update_samplers_struct_wrapper();
-    xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct);
-    xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct);
-
-    virtual ~xgl_update_samplers_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_index() { return m_struct.index; }
-    void set_index(uint32_t inValue) { m_struct.index = inValue; }
-    uint32_t get_count() { return m_struct.count; }
-    void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
-    XGL_UPDATE_SAMPLERS m_struct;
-    const XGL_UPDATE_SAMPLERS* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_create_info_struct_wrapper
-{
-public:
-    xgl_image_create_info_struct_wrapper();
-    xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct);
-    xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_image_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    XGL_IMAGE_TYPE get_imageType() { return m_struct.imageType; }
-    void set_imageType(XGL_IMAGE_TYPE inValue) { m_struct.imageType = inValue; }
-    XGL_FORMAT get_format() { return m_struct.format; }
-    void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
-    XGL_EXTENT3D get_extent() { return m_struct.extent; }
-    void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
-    uint32_t get_mipLevels() { return m_struct.mipLevels; }
-    void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
-    uint32_t get_arraySize() { return m_struct.arraySize; }
-    void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
-    uint32_t get_samples() { return m_struct.samples; }
-    void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
-    XGL_IMAGE_TILING get_tiling() { return m_struct.tiling; }
-    void set_tiling(XGL_IMAGE_TILING inValue) { m_struct.tiling = inValue; }
-    XGL_FLAGS get_usage() { return m_struct.usage; }
-    void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
-    XGL_FLAGS get_flags() { return m_struct.flags; }
-    void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
-    XGL_IMAGE_CREATE_INFO m_struct;
-    const XGL_IMAGE_CREATE_INFO* m_origStructAddr;
-    uint32_t m_indent;
-    const char m_dummy_prefix;
-    void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_tess_state_create_info_struct_wrapper
-{
-public:
-    xgl_pipeline_tess_state_create_info_struct_wrapper();
-    xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
-    xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
-
-    virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper();
-
-    void display_txt();
-    void display_single_txt();
-    void display_full_txt();
-
-    void set_indent(uint32_t indent) { m_indent = indent; }
-    XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
-    void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
-    const void* get_pNext() { return m_struct.pNext; }
-    uint32_t get_patchControlPoints() { return m_struct.patchControlPoints; }
-    void set_patchControlPoints(uint32_t inValue) { m_struct.patchControlPoints = inValue; }
-    float get_optimalTessFactor() { return m_struct.optimalTessFactor; }
-    void set_optimalTessFactor(float inValue) { m_struct.optimalTessFactor = inValue; }
-    float get_fixedTessFactor() { return m_struct.fixedTessFactor; }
-    void set_fixedTessFactor(float inValue) { m_struct.fixedTessFactor = inValue; }
-
-
-private:
-    XGL_PIPELINE_TESS_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr;
+    XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct;
+    const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();