glave: add codegen'd files that come from driver's xgl_helper.py

* These are now confirmed to be consistent between builds.

Conflicts:
	tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h
	tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h
	tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h
	tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h
	tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h
	tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h
	tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h
	tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h
	tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h
	tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h
	tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp
	tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.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 1322edf..72340ea 100644 (file)
--- 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,190 +3,228 @@
 #include <xgl.h>
 
 
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
 {
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
     {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_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_PIPELINE_CREATE_FLAGS";
+            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
 {
-    switch ((XGL_IMAGE_TILING)input_value)
+    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
     {
-        case XGL_LINEAR_TILING:
-            return "XGL_LINEAR_TILING";
-        case XGL_OPTIMAL_TILING:
-            return "XGL_OPTIMAL_TILING";
+        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_IMAGE_TILING";
+            return "Unhandled XGL_ATTACHMENT_STORE_OP";
     }
 }
 
 
-static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
 {
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+    switch ((XGL_BLEND)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";
+        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_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+            return "Unhandled XGL_BLEND";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 {
-    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+    switch ((XGL_BLEND_FUNC)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_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_IMAGE_FORMAT_CLASS";
+            return "Unhandled XGL_BLEND_FUNC";
     }
 }
 
 
-static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
 {
-    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+    switch ((XGL_BORDER_COLOR_TYPE)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";
+        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_FORMAT_FEATURE_FLAGS";
+            return "Unhandled XGL_BORDER_COLOR_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+    switch ((XGL_BUFFER_CREATE_FLAGS)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";
+        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_IMAGE_VIEW_TYPE";
+            return "Unhandled XGL_BUFFER_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    switch ((XGL_BUFFER_USAGE_FLAGS)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_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_PHYSICAL_GPU_TYPE";
+            return "Unhandled XGL_BUFFER_USAGE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
 {
-    switch ((XGL_QUERY_TYPE)input_value)
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
     {
-        case XGL_QUERY_OCCLUSION:
-            return "XGL_QUERY_OCCLUSION";
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return "XGL_QUERY_PIPELINE_STATISTICS";
+        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_QUERY_TYPE";
+            return "Unhandled XGL_BUFFER_VIEW_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
 {
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+    switch ((XGL_CHANNEL_SWIZZLE)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";
-    }
-}
+        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_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_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
@@ -215,921 +253,189 @@ static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
 }
 
 
-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_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
 {
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    switch ((XGL_COORDINATE_ORIGIN)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_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_ATTACHMENT_LOAD_OP";
+            return "Unhandled XGL_COORDINATE_ORIGIN";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
 {
-    switch ((XGL_IMAGE_ASPECT)input_value)
+    switch ((XGL_CULL_MODE)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_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_IMAGE_ASPECT";
+            return "Unhandled XGL_CULL_MODE";
     }
 }
 
 
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+    switch ((XGL_DEPTH_MODE)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";
+        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_BUFFER_CREATE_FLAGS";
+            return "Unhandled XGL_DEPTH_MODE";
     }
 }
 
 
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
 {
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_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_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_GPU_COMPATIBILITY_FLAGS";
+            return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-            return "XGL_FRONT_FACE_CCW";
-        case XGL_FRONT_FACE_CW:
-            return "XGL_FRONT_FACE_CW";
+        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_FACE_ORIENTATION";
+            return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
     }
 }
 
 
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-            return "XGL_TEX_FILTER_LINEAR";
-        case XGL_TEX_FILTER_NEAREST:
-            return "XGL_TEX_FILTER_NEAREST";
+        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_TEX_FILTER";
+            return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
     }
 }
 
 
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
 {
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_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";
+        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_BUFFER_VIEW_TYPE";
+            return "Unhandled XGL_DESCRIPTOR_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
 {
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
     {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+        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_SEMAPHORE_CREATE_FLAGS";
+            return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
     }
 }
 
 
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    switch ((XGL_DEVICE_CREATE_FLAGS)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";
+        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_PHYSICAL_GPU_INFO_TYPE";
+            return "Unhandled XGL_DEVICE_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
 {
-    switch ((XGL_QUEUE_TYPE)input_value)
+    switch ((XGL_FACE_ORIENTATION)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_FRONT_FACE_CCW:
+            return "XGL_FRONT_FACE_CCW";
+        case XGL_FRONT_FACE_CW:
+            return "XGL_FRONT_FACE_CW";
         default:
-            return "Unhandled XGL_QUEUE_TYPE";
+            return "Unhandled XGL_FACE_ORIENTATION";
     }
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
 {
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    switch ((XGL_FILL_MODE)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_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_DESCRIPTOR_SET_USAGE";
+            return "Unhandled XGL_FILL_MODE";
     }
 }
 
 
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+static inline const char* string_XGL_FORMAT(XGL_FORMAT 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";
-    }
-}
-
-
-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_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_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_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_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_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_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_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_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";
-    }
-}
-
-
-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_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_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_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";
-    }
-}
-
-
-static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
-{
-    switch ((XGL_FORMAT)input_value)
+    switch ((XGL_FORMAT)input_value)
     {
         case XGL_FMT_ASTC_10x10_SRGB:
             return "XGL_FMT_ASTC_10x10_SRGB";
@@ -1466,81 +772,617 @@ static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
         case XGL_FMT_UNDEFINED:
             return "XGL_FMT_UNDEFINED";
         default:
-            return "Unhandled XGL_FORMAT";
+            return "Unhandled XGL_FORMAT";
+    }
+}
+
+
+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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
 {
-    switch ((XGL_TEX_ADDRESS)input_value)
+    switch ((XGL_PRIMITIVE_TOPOLOGY)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_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_TEX_ADDRESS";
+            return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
     }
 }
 
 
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
 {
-    switch ((XGL_DEPTH_MODE)input_value)
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)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_PROVOKING_VERTEX_FIRST:
+            return "XGL_PROVOKING_VERTEX_FIRST";
+        case XGL_PROVOKING_VERTEX_LAST:
+            return "XGL_PROVOKING_VERTEX_LAST";
         default:
-            return "Unhandled XGL_DEPTH_MODE";
+            return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
     }
 }
 
 
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
 {
-    switch ((XGL_MEMORY_PRIORITY)input_value)
+    switch ((XGL_QUERY_CONTROL_FLAGS)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";
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
+            return "XGL_QUERY_IMPRECISE_DATA_BIT";
         default:
-            return "Unhandled XGL_MEMORY_PRIORITY";
+            return "Unhandled XGL_QUERY_CONTROL_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline const char* string_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:
-            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_QUERY_OCCLUSION:
+            return "XGL_QUERY_OCCLUSION";
+        case XGL_QUERY_PIPELINE_STATISTICS:
+            return "XGL_QUERY_PIPELINE_STATISTICS";
         default:
-            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+            return "Unhandled XGL_QUERY_TYPE";
     }
 }
 
@@ -1558,49 +1400,217 @@ static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
         case XGL_QUEUE_GRAPHICS_BIT:
             return "XGL_QUEUE_GRAPHICS_BIT";
         default:
-            return "Unhandled XGL_QUEUE_FLAGS";
+            return "Unhandled XGL_QUEUE_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_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_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_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_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_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+    switch ((XGL_STATE_BIND_POINT)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_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_INPUT_FLAGS";
+            return "Unhandled XGL_STATE_BIND_POINT";
     }
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
 {
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+    switch ((XGL_STENCIL_OP)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_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_DESCRIPTOR_REGION_USAGE";
+            return "Unhandled XGL_STENCIL_OP";
     }
 }
 
@@ -1725,158 +1735,148 @@ static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_val
 }
 
 
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)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_INFO_TYPE_SUBRESOURCE_LAYOUT:
+            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
         default:
-            return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+            return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
 {
-    switch ((XGL_LOGIC_OP)input_value)
+    switch ((XGL_SYSTEM_ALLOC_TYPE)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_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_LOGIC_OP";
+            return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    switch ((XGL_TEX_ADDRESS)input_value)
     {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
-            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+        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_FORMAT_INFO_TYPE";
+            return "Unhandled XGL_TEX_ADDRESS";
     }
 }
 
 
-static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 {
-    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    switch ((XGL_TEX_FILTER)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_TEX_FILTER_LINEAR:
+            return "XGL_TEX_FILTER_LINEAR";
+        case XGL_TEX_FILTER_NEAREST:
+            return "XGL_TEX_FILTER_NEAREST";
         default:
-            return "Unhandled XGL_CHANNEL_SWIZZLE";
+            return "Unhandled XGL_TEX_FILTER";
     }
 }
 
 
-static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
 {
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    switch ((XGL_TEX_MIPMAP_MODE)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_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_PIPELINE_BIND_POINT";
+            return "Unhandled XGL_TEX_MIPMAP_MODE";
     }
 }
 
 
-static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
     {
-        case XGL_PROVOKING_VERTEX_FIRST:
-            return "XGL_PROVOKING_VERTEX_FIRST";
-        case XGL_PROVOKING_VERTEX_LAST:
-            return "XGL_PROVOKING_VERTEX_LAST";
+        case XGL_TIMESTAMP_BOTTOM:
+            return "XGL_TIMESTAMP_BOTTOM";
+        case XGL_TIMESTAMP_TOP:
+            return "XGL_TIMESTAMP_TOP";
         default:
-            return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
+            return "Unhandled XGL_TIMESTAMP_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
 {
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
+    switch ((XGL_VALIDATION_LEVEL)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_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_OBJECT_INFO_TYPE";
+            return "Unhandled XGL_VALIDATION_LEVEL";
     }
 }
 
 
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
 {
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)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_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_DEVICE_CREATE_FLAGS";
+            return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
+    }
+}
+
+
+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";
     }
 }
 

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 36d35e6..9327b39 100644 (file)
--- 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,11 +3,13 @@
 #include <xgl.h>
 
 
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
 {
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
     {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_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;
@@ -15,12 +17,13 @@ static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FL
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
 {
-    switch ((XGL_IMAGE_TILING)input_value)
+    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
     {
-        case XGL_LINEAR_TILING:
-        case XGL_OPTIMAL_TILING:
+        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;
@@ -28,12 +31,29 @@ static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
 }
 
 
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
 {
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+    switch ((XGL_BLEND)input_value)
     {
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+        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;
@@ -41,28 +61,15 @@ static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_ST
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 {
-    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+    switch ((XGL_BLEND_FUNC)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_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;
@@ -70,20 +77,13 @@ static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS in
 }
 
 
-static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
 {
-    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+    switch ((XGL_BORDER_COLOR_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_BORDER_COLOR_OPAQUE_BLACK:
+        case XGL_BORDER_COLOR_OPAQUE_WHITE:
+        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
             return 1;
         default:
             return 0;
@@ -91,14 +91,12 @@ static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAG
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
     {
-        case XGL_IMAGE_VIEW_1D:
-        case XGL_IMAGE_VIEW_2D:
-        case XGL_IMAGE_VIEW_3D:
-        case XGL_IMAGE_VIEW_CUBE:
+        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+        case XGL_BUFFER_CREATE_SPARSE_BIT:
             return 1;
         default:
             return 0;
@@ -106,14 +104,24 @@ static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_va
 }
 
 
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
     {
-        case XGL_GPU_TYPE_DISCRETE:
-        case XGL_GPU_TYPE_INTEGRATED:
-        case XGL_GPU_TYPE_OTHER:
-        case XGL_GPU_TYPE_VIRTUAL:
+        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;
@@ -121,12 +129,13 @@ static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE inpu
 }
 
 
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
 {
-    switch ((XGL_QUERY_TYPE)input_value)
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
     {
-        case XGL_QUERY_OCCLUSION:
-        case XGL_QUERY_PIPELINE_STATISTICS:
+        case XGL_BUFFER_VIEW_RAW:
+        case XGL_BUFFER_VIEW_STRUCTURED:
+        case XGL_BUFFER_VIEW_TYPED:
             return 1;
         default:
             return 0;
@@ -134,15 +143,31 @@ static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
 {
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+    switch ((XGL_CHANNEL_SWIZZLE)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:
+        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_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;
@@ -169,13 +194,12 @@ static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
 }
 
 
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
 {
-    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+    switch ((XGL_COORDINATE_ORIGIN)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_COORDINATE_ORIGIN_LOWER_LEFT:
+        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
             return 1;
         default:
             return 0;
@@ -183,13 +207,14 @@ static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
 {
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    switch ((XGL_CULL_MODE)input_value)
     {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+        case XGL_CULL_BACK:
+        case XGL_CULL_FRONT:
+        case XGL_CULL_FRONT_AND_BACK:
+        case XGL_CULL_NONE:
             return 1;
         default:
             return 0;
@@ -197,13 +222,12 @@ static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP in
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_IMAGE_ASPECT)input_value)
+    switch ((XGL_DEPTH_MODE)input_value)
     {
-        case XGL_IMAGE_ASPECT_COLOR:
-        case XGL_IMAGE_ASPECT_DEPTH:
-        case XGL_IMAGE_ASPECT_STENCIL:
+        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+        case XGL_DEPTH_MODE_ZERO_TO_ONE:
             return 1;
         default:
             return 0;
@@ -211,12 +235,12 @@ static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
 {
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
     {
-        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
-        case XGL_BUFFER_CREATE_SPARSE_BIT:
+        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;
@@ -224,17 +248,12 @@ static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS
 }
 
 
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
 {
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)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_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
             return 1;
         default:
             return 0;
@@ -242,12 +261,12 @@ static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILIT
 }
 
 
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-        case XGL_FRONT_FACE_CW:
+        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
             return 1;
         default:
             return 0;
@@ -255,12 +274,22 @@ static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_
 }
 
 
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_DESCRIPTOR_TYPE)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-        case XGL_TEX_FILTER_NEAREST:
+        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;
@@ -268,13 +297,12 @@ static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
 {
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
     {
-        case XGL_BUFFER_VIEW_RAW:
-        case XGL_BUFFER_VIEW_STRUCTURED:
-        case XGL_BUFFER_VIEW_TYPED:
+        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
             return 1;
         default:
             return 0;
@@ -282,11 +310,12 @@ static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_
 }
 
 
-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:
+        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+        case XGL_DEVICE_CREATE_VALIDATION_BIT:
             return 1;
         default:
             return 0;
@@ -294,54 +323,12 @@ static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_
 }
 
 
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    switch ((XGL_FACE_ORIENTATION)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:
+        case XGL_FRONT_FACE_CCW:
+        case XGL_FRONT_FACE_CW:
             return 1;
         default:
             return 0;
@@ -363,72 +350,177 @@ static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
 }
 
 
-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;
-    }
-}
-
-
-static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
-{
-    switch ((XGL_BUFFER_USAGE_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_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
 {
-    switch ((XGL_BLEND_FUNC)input_value)
+    switch ((XGL_FORMAT)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_FMT_ASTC_10x10_SRGB:
+        case XGL_FMT_ASTC_10x10_UNORM:
+        case XGL_FMT_ASTC_10x5_SRGB:
+        case XGL_FMT_ASTC_10x5_UNORM:
+        case XGL_FMT_ASTC_10x6_SRGB:
+        case XGL_FMT_ASTC_10x6_UNORM:
+        case XGL_FMT_ASTC_10x8_SRGB:
+        case XGL_FMT_ASTC_10x8_UNORM:
+        case XGL_FMT_ASTC_12x10_SRGB:
+        case XGL_FMT_ASTC_12x10_UNORM:
+        case XGL_FMT_ASTC_12x12_SRGB:
+        case XGL_FMT_ASTC_12x12_UNORM:
+        case XGL_FMT_ASTC_4x4_SRGB:
+        case XGL_FMT_ASTC_4x4_UNORM:
+        case XGL_FMT_ASTC_4x5_SRGB:
+        case XGL_FMT_ASTC_4x5_UNORM:
+        case XGL_FMT_ASTC_5x5_SRGB:
+        case XGL_FMT_ASTC_5x5_UNORM:
+        case XGL_FMT_ASTC_6x5_SRGB:
+        case XGL_FMT_ASTC_6x5_UNORM:
+        case XGL_FMT_ASTC_6x6_SRGB:
+        case XGL_FMT_ASTC_6x6_UNORM:
+        case XGL_FMT_ASTC_8x5_SRGB:
+        case XGL_FMT_ASTC_8x5_UNORM:
+        case XGL_FMT_ASTC_8x6_SRGB:
+        case XGL_FMT_ASTC_8x6_UNORM:
+        case XGL_FMT_ASTC_8x8_SRGB:
+        case XGL_FMT_ASTC_8x8_UNORM:
+        case XGL_FMT_B10G10R10A2_SINT:
+        case XGL_FMT_B10G10R10A2_SNORM:
+        case XGL_FMT_B10G10R10A2_SSCALED:
+        case XGL_FMT_B10G10R10A2_UINT:
+        case XGL_FMT_B10G10R10A2_UNORM:
+        case XGL_FMT_B10G10R10A2_USCALED:
+        case XGL_FMT_B5G6R5_UNORM:
+        case XGL_FMT_B5G6R5_USCALED:
+        case XGL_FMT_B8G8R8A8_SINT:
+        case XGL_FMT_B8G8R8A8_SNORM:
+        case XGL_FMT_B8G8R8A8_SRGB:
+        case XGL_FMT_B8G8R8A8_SSCALED:
+        case XGL_FMT_B8G8R8A8_UINT:
+        case XGL_FMT_B8G8R8A8_UNORM:
+        case XGL_FMT_B8G8R8A8_USCALED:
+        case XGL_FMT_B8G8R8_SINT:
+        case XGL_FMT_B8G8R8_SNORM:
+        case XGL_FMT_B8G8R8_SRGB:
+        case XGL_FMT_B8G8R8_SSCALED:
+        case XGL_FMT_B8G8R8_UINT:
+        case XGL_FMT_B8G8R8_UNORM:
+        case XGL_FMT_B8G8R8_USCALED:
+        case XGL_FMT_BC1_SRGB:
+        case XGL_FMT_BC1_UNORM:
+        case XGL_FMT_BC2_SRGB:
+        case XGL_FMT_BC2_UNORM:
+        case XGL_FMT_BC3_SRGB:
+        case XGL_FMT_BC3_UNORM:
+        case XGL_FMT_BC4_SNORM:
+        case XGL_FMT_BC4_UNORM:
+        case XGL_FMT_BC5_SNORM:
+        case XGL_FMT_BC5_UNORM:
+        case XGL_FMT_BC6H_SFLOAT:
+        case XGL_FMT_BC6H_UFLOAT:
+        case XGL_FMT_BC7_SRGB:
+        case XGL_FMT_BC7_UNORM:
+        case XGL_FMT_D16_UNORM:
+        case XGL_FMT_D16_UNORM_S8_UINT:
+        case XGL_FMT_D24_UNORM:
+        case XGL_FMT_D24_UNORM_S8_UINT:
+        case XGL_FMT_D32_SFLOAT:
+        case XGL_FMT_D32_SFLOAT_S8_UINT:
+        case XGL_FMT_EAC_R11G11_SNORM:
+        case XGL_FMT_EAC_R11G11_UNORM:
+        case XGL_FMT_EAC_R11_SNORM:
+        case XGL_FMT_EAC_R11_UNORM:
+        case XGL_FMT_ETC2_R8G8B8A1_UNORM:
+        case XGL_FMT_ETC2_R8G8B8A8_UNORM:
+        case XGL_FMT_ETC2_R8G8B8_UNORM:
+        case XGL_FMT_R10G10B10A2_SINT:
+        case XGL_FMT_R10G10B10A2_SNORM:
+        case XGL_FMT_R10G10B10A2_SSCALED:
+        case XGL_FMT_R10G10B10A2_UINT:
+        case XGL_FMT_R10G10B10A2_UNORM:
+        case XGL_FMT_R10G10B10A2_USCALED:
+        case XGL_FMT_R11G11B10_UFLOAT:
+        case XGL_FMT_R16G16B16A16_SFLOAT:
+        case XGL_FMT_R16G16B16A16_SINT:
+        case XGL_FMT_R16G16B16A16_SNORM:
+        case XGL_FMT_R16G16B16A16_SSCALED:
+        case XGL_FMT_R16G16B16A16_UINT:
+        case XGL_FMT_R16G16B16A16_UNORM:
+        case XGL_FMT_R16G16B16A16_USCALED:
+        case XGL_FMT_R16G16B16_SFLOAT:
+        case XGL_FMT_R16G16B16_SINT:
+        case XGL_FMT_R16G16B16_SNORM:
+        case XGL_FMT_R16G16B16_SSCALED:
+        case XGL_FMT_R16G16B16_UINT:
+        case XGL_FMT_R16G16B16_UNORM:
+        case XGL_FMT_R16G16B16_USCALED:
+        case XGL_FMT_R16G16_SFLOAT:
+        case XGL_FMT_R16G16_SINT:
+        case XGL_FMT_R16G16_SNORM:
+        case XGL_FMT_R16G16_SSCALED:
+        case XGL_FMT_R16G16_UINT:
+        case XGL_FMT_R16G16_UNORM:
+        case XGL_FMT_R16G16_USCALED:
+        case XGL_FMT_R16_SFLOAT:
+        case XGL_FMT_R16_SINT:
+        case XGL_FMT_R16_SNORM:
+        case XGL_FMT_R16_SSCALED:
+        case XGL_FMT_R16_UINT:
+        case XGL_FMT_R16_UNORM:
+        case XGL_FMT_R16_USCALED:
+        case XGL_FMT_R32G32B32A32_SFLOAT:
+        case XGL_FMT_R32G32B32A32_SINT:
+        case XGL_FMT_R32G32B32A32_UINT:
+        case XGL_FMT_R32G32B32_SFLOAT:
+        case XGL_FMT_R32G32B32_SINT:
+        case XGL_FMT_R32G32B32_UINT:
+        case XGL_FMT_R32G32_SFLOAT:
+        case XGL_FMT_R32G32_SINT:
+        case XGL_FMT_R32G32_UINT:
+        case XGL_FMT_R32_SFLOAT:
+        case XGL_FMT_R32_SINT:
+        case XGL_FMT_R32_UINT:
+        case XGL_FMT_R4G4B4A4_UNORM:
+        case XGL_FMT_R4G4B4A4_USCALED:
+        case XGL_FMT_R4G4_UNORM:
+        case XGL_FMT_R4G4_USCALED:
+        case XGL_FMT_R5G5B5A1_UNORM:
+        case XGL_FMT_R5G5B5A1_USCALED:
+        case XGL_FMT_R5G6B5_UNORM:
+        case XGL_FMT_R5G6B5_USCALED:
+        case XGL_FMT_R64G64B64A64_SFLOAT:
+        case XGL_FMT_R64G64B64_SFLOAT:
+        case XGL_FMT_R64G64_SFLOAT:
+        case XGL_FMT_R64_SFLOAT:
+        case XGL_FMT_R8G8B8A8_SINT:
+        case XGL_FMT_R8G8B8A8_SNORM:
+        case XGL_FMT_R8G8B8A8_SRGB:
+        case XGL_FMT_R8G8B8A8_SSCALED:
+        case XGL_FMT_R8G8B8A8_UINT:
+        case XGL_FMT_R8G8B8A8_UNORM:
+        case XGL_FMT_R8G8B8A8_USCALED:
+        case XGL_FMT_R8G8B8_SINT:
+        case XGL_FMT_R8G8B8_SNORM:
+        case XGL_FMT_R8G8B8_SRGB:
+        case XGL_FMT_R8G8B8_SSCALED:
+        case XGL_FMT_R8G8B8_UINT:
+        case XGL_FMT_R8G8B8_UNORM:
+        case XGL_FMT_R8G8B8_USCALED:
+        case XGL_FMT_R8G8_SINT:
+        case XGL_FMT_R8G8_SNORM:
+        case XGL_FMT_R8G8_SRGB:
+        case XGL_FMT_R8G8_SSCALED:
+        case XGL_FMT_R8G8_UINT:
+        case XGL_FMT_R8G8_UNORM:
+        case XGL_FMT_R8G8_USCALED:
+        case XGL_FMT_R8_SINT:
+        case XGL_FMT_R8_SNORM:
+        case XGL_FMT_R8_SRGB:
+        case XGL_FMT_R8_SSCALED:
+        case XGL_FMT_R8_UINT:
+        case XGL_FMT_R8_UNORM:
+        case XGL_FMT_R8_USCALED:
+        case XGL_FMT_R9G9B9E5_UFLOAT:
+        case XGL_FMT_S8_UINT:
+        case XGL_FMT_UNDEFINED:
             return 1;
         default:
             return 0;
@@ -436,20 +528,20 @@ static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+    switch ((XGL_FORMAT_FEATURE_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:
+        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;
@@ -457,17 +549,11 @@ static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS inpu
 }
 
 
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
 {
-    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    switch ((XGL_FORMAT_INFO_TYPE)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_INFO_TYPE_FORMAT_PROPERTIES:
             return 1;
         default:
             return 0;
@@ -475,64 +561,31 @@ static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS in
 }
 
 
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
     {
-        case XGL_TEX_MIPMAP_BASE:
-        case XGL_TEX_MIPMAP_LINEAR:
-        case XGL_TEX_MIPMAP_NEAREST:
+        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_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:
+    }
+}
+
+
+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;
@@ -540,17 +593,15 @@ static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
 }
 
 
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_SET_EVENT)input_value)
+    switch ((XGL_IMAGE_CREATE_FLAGS)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:
+        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;
@@ -558,14 +609,28 @@ static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
 }
 
 
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
 {
-    switch ((XGL_STATE_BIND_POINT)input_value)
+    switch ((XGL_IMAGE_FORMAT_CLASS)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_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;
@@ -592,12 +657,12 @@ static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
 {
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    switch ((XGL_IMAGE_TILING)input_value)
     {
-        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
-        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+        case XGL_LINEAR_TILING:
+        case XGL_OPTIMAL_TILING:
             return 1;
         default:
             return 0;
@@ -605,13 +670,13 @@ static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
 {
-    switch ((XGL_MEMORY_TYPE)input_value)
+    switch ((XGL_IMAGE_TYPE)input_value)
     {
-        case XGL_MEMORY_TYPE_BUFFER:
-        case XGL_MEMORY_TYPE_IMAGE:
-        case XGL_MEMORY_TYPE_OTHER:
+        case XGL_IMAGE_1D:
+        case XGL_IMAGE_2D:
+        case XGL_IMAGE_3D:
             return 1;
         default:
             return 0;
@@ -619,14 +684,20 @@ static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
 {
-    switch ((XGL_CULL_MODE)input_value)
+    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
     {
-        case XGL_CULL_BACK:
-        case XGL_CULL_FRONT:
-        case XGL_CULL_FRONT_AND_BACK:
-        case XGL_CULL_NONE:
+        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;
@@ -634,11 +705,14 @@ static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
 }
 
 
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
 {
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
     {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+        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;
@@ -646,11 +720,13 @@ static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_T
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
 {
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
+    switch ((XGL_INDEX_TYPE)input_value)
     {
-        case XGL_MEMORY_REF_READ_ONLY_BIT:
+        case XGL_INDEX_16:
+        case XGL_INDEX_32:
+        case XGL_INDEX_8:
             return 1;
         default:
             return 0;
@@ -658,11 +734,79 @@ static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_
 }
 
 
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
 {
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    switch ((XGL_LOGIC_OP)input_value)
     {
-        case XGL_QUERY_IMPRECISE_DATA_BIT:
+        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_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_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_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;
@@ -688,12 +832,11 @@ static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FL
 }
 
 
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
 {
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
+    switch ((XGL_MEMORY_REF_FLAGS)input_value)
     {
-        case XGL_TIMESTAMP_BOTTOM:
-        case XGL_TIMESTAMP_TOP:
+        case XGL_MEMORY_REF_READ_ONLY_BIT:
             return 1;
         default:
             return 0;
@@ -701,13 +844,13 @@ static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_valu
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_MEMORY_TYPE)input_value)
     {
-        case XGL_IMAGE_1D:
-        case XGL_IMAGE_2D:
-        case XGL_IMAGE_3D:
+        case XGL_MEMORY_TYPE_BUFFER:
+        case XGL_MEMORY_TYPE_IMAGE:
+        case XGL_MEMORY_TYPE_OTHER:
             return 1;
         default:
             return 0;
@@ -715,16 +858,14 @@ static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
 {
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    switch ((XGL_OBJECT_INFO_TYPE)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_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;
@@ -732,29 +873,14 @@ static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_ST
 }
 
 
-static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
 {
-    switch ((XGL_BLEND)input_value)
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)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:
+        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;
@@ -762,23 +888,14 @@ static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
 }
 
 
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE 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:
+    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;
@@ -786,15 +903,12 @@ static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY in
 }
 
 
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
 {
-    switch ((XGL_VALIDATION_LEVEL)input_value)
+    switch ((XGL_PIPELINE_BIND_POINT)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:
+        case XGL_PIPELINE_BIND_POINT_COMPUTE:
+        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -802,22 +916,11 @@ static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    switch ((XGL_PIPELINE_CREATE_FLAGS)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_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
             return 1;
         default:
             return 0;
@@ -825,13 +928,16 @@ static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_va
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
 {
-    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
     {
-        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
-        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
-        case XGL_ATTACHMENT_STORE_OP_STORE:
+        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;
@@ -839,15 +945,23 @@ static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
 {
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    switch ((XGL_PRIMITIVE_TOPOLOGY)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_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;
@@ -855,13 +969,12 @@ static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS in
 }
 
 
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
 {
-    switch ((XGL_INDEX_TYPE)input_value)
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
     {
-        case XGL_INDEX_16:
-        case XGL_INDEX_32:
-        case XGL_INDEX_8:
+        case XGL_PROVOKING_VERTEX_FIRST:
+        case XGL_PROVOKING_VERTEX_LAST:
             return 1;
         default:
             return 0;
@@ -869,13 +982,11 @@ static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
 {
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
     {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
             return 1;
         default:
             return 0;
@@ -883,177 +994,12 @@ static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE inpu
 }
 
 
-static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 {
-    switch ((XGL_FORMAT)input_value)
+    switch ((XGL_QUERY_TYPE)input_value)
     {
-        case XGL_FMT_ASTC_10x10_SRGB:
-        case XGL_FMT_ASTC_10x10_UNORM:
-        case XGL_FMT_ASTC_10x5_SRGB:
-        case XGL_FMT_ASTC_10x5_UNORM:
-        case XGL_FMT_ASTC_10x6_SRGB:
-        case XGL_FMT_ASTC_10x6_UNORM:
-        case XGL_FMT_ASTC_10x8_SRGB:
-        case XGL_FMT_ASTC_10x8_UNORM:
-        case XGL_FMT_ASTC_12x10_SRGB:
-        case XGL_FMT_ASTC_12x10_UNORM:
-        case XGL_FMT_ASTC_12x12_SRGB:
-        case XGL_FMT_ASTC_12x12_UNORM:
-        case XGL_FMT_ASTC_4x4_SRGB:
-        case XGL_FMT_ASTC_4x4_UNORM:
-        case XGL_FMT_ASTC_4x5_SRGB:
-        case XGL_FMT_ASTC_4x5_UNORM:
-        case XGL_FMT_ASTC_5x5_SRGB:
-        case XGL_FMT_ASTC_5x5_UNORM:
-        case XGL_FMT_ASTC_6x5_SRGB:
-        case XGL_FMT_ASTC_6x5_UNORM:
-        case XGL_FMT_ASTC_6x6_SRGB:
-        case XGL_FMT_ASTC_6x6_UNORM:
-        case XGL_FMT_ASTC_8x5_SRGB:
-        case XGL_FMT_ASTC_8x5_UNORM:
-        case XGL_FMT_ASTC_8x6_SRGB:
-        case XGL_FMT_ASTC_8x6_UNORM:
-        case XGL_FMT_ASTC_8x8_SRGB:
-        case XGL_FMT_ASTC_8x8_UNORM:
-        case XGL_FMT_B10G10R10A2_SINT:
-        case XGL_FMT_B10G10R10A2_SNORM:
-        case XGL_FMT_B10G10R10A2_SSCALED:
-        case XGL_FMT_B10G10R10A2_UINT:
-        case XGL_FMT_B10G10R10A2_UNORM:
-        case XGL_FMT_B10G10R10A2_USCALED:
-        case XGL_FMT_B5G6R5_UNORM:
-        case XGL_FMT_B5G6R5_USCALED:
-        case XGL_FMT_B8G8R8A8_SINT:
-        case XGL_FMT_B8G8R8A8_SNORM:
-        case XGL_FMT_B8G8R8A8_SRGB:
-        case XGL_FMT_B8G8R8A8_SSCALED:
-        case XGL_FMT_B8G8R8A8_UINT:
-        case XGL_FMT_B8G8R8A8_UNORM:
-        case XGL_FMT_B8G8R8A8_USCALED:
-        case XGL_FMT_B8G8R8_SINT:
-        case XGL_FMT_B8G8R8_SNORM:
-        case XGL_FMT_B8G8R8_SRGB:
-        case XGL_FMT_B8G8R8_SSCALED:
-        case XGL_FMT_B8G8R8_UINT:
-        case XGL_FMT_B8G8R8_UNORM:
-        case XGL_FMT_B8G8R8_USCALED:
-        case XGL_FMT_BC1_SRGB:
-        case XGL_FMT_BC1_UNORM:
-        case XGL_FMT_BC2_SRGB:
-        case XGL_FMT_BC2_UNORM:
-        case XGL_FMT_BC3_SRGB:
-        case XGL_FMT_BC3_UNORM:
-        case XGL_FMT_BC4_SNORM:
-        case XGL_FMT_BC4_UNORM:
-        case XGL_FMT_BC5_SNORM:
-        case XGL_FMT_BC5_UNORM:
-        case XGL_FMT_BC6H_SFLOAT:
-        case XGL_FMT_BC6H_UFLOAT:
-        case XGL_FMT_BC7_SRGB:
-        case XGL_FMT_BC7_UNORM:
-        case XGL_FMT_D16_UNORM:
-        case XGL_FMT_D16_UNORM_S8_UINT:
-        case XGL_FMT_D24_UNORM:
-        case XGL_FMT_D24_UNORM_S8_UINT:
-        case XGL_FMT_D32_SFLOAT:
-        case XGL_FMT_D32_SFLOAT_S8_UINT:
-        case XGL_FMT_EAC_R11G11_SNORM:
-        case XGL_FMT_EAC_R11G11_UNORM:
-        case XGL_FMT_EAC_R11_SNORM:
-        case XGL_FMT_EAC_R11_UNORM:
-        case XGL_FMT_ETC2_R8G8B8A1_UNORM:
-        case XGL_FMT_ETC2_R8G8B8A8_UNORM:
-        case XGL_FMT_ETC2_R8G8B8_UNORM:
-        case XGL_FMT_R10G10B10A2_SINT:
-        case XGL_FMT_R10G10B10A2_SNORM:
-        case XGL_FMT_R10G10B10A2_SSCALED:
-        case XGL_FMT_R10G10B10A2_UINT:
-        case XGL_FMT_R10G10B10A2_UNORM:
-        case XGL_FMT_R10G10B10A2_USCALED:
-        case XGL_FMT_R11G11B10_UFLOAT:
-        case XGL_FMT_R16G16B16A16_SFLOAT:
-        case XGL_FMT_R16G16B16A16_SINT:
-        case XGL_FMT_R16G16B16A16_SNORM:
-        case XGL_FMT_R16G16B16A16_SSCALED:
-        case XGL_FMT_R16G16B16A16_UINT:
-        case XGL_FMT_R16G16B16A16_UNORM:
-        case XGL_FMT_R16G16B16A16_USCALED:
-        case XGL_FMT_R16G16B16_SFLOAT:
-        case XGL_FMT_R16G16B16_SINT:
-        case XGL_FMT_R16G16B16_SNORM:
-        case XGL_FMT_R16G16B16_SSCALED:
-        case XGL_FMT_R16G16B16_UINT:
-        case XGL_FMT_R16G16B16_UNORM:
-        case XGL_FMT_R16G16B16_USCALED:
-        case XGL_FMT_R16G16_SFLOAT:
-        case XGL_FMT_R16G16_SINT:
-        case XGL_FMT_R16G16_SNORM:
-        case XGL_FMT_R16G16_SSCALED:
-        case XGL_FMT_R16G16_UINT:
-        case XGL_FMT_R16G16_UNORM:
-        case XGL_FMT_R16G16_USCALED:
-        case XGL_FMT_R16_SFLOAT:
-        case XGL_FMT_R16_SINT:
-        case XGL_FMT_R16_SNORM:
-        case XGL_FMT_R16_SSCALED:
-        case XGL_FMT_R16_UINT:
-        case XGL_FMT_R16_UNORM:
-        case XGL_FMT_R16_USCALED:
-        case XGL_FMT_R32G32B32A32_SFLOAT:
-        case XGL_FMT_R32G32B32A32_SINT:
-        case XGL_FMT_R32G32B32A32_UINT:
-        case XGL_FMT_R32G32B32_SFLOAT:
-        case XGL_FMT_R32G32B32_SINT:
-        case XGL_FMT_R32G32B32_UINT:
-        case XGL_FMT_R32G32_SFLOAT:
-        case XGL_FMT_R32G32_SINT:
-        case XGL_FMT_R32G32_UINT:
-        case XGL_FMT_R32_SFLOAT:
-        case XGL_FMT_R32_SINT:
-        case XGL_FMT_R32_UINT:
-        case XGL_FMT_R4G4B4A4_UNORM:
-        case XGL_FMT_R4G4B4A4_USCALED:
-        case XGL_FMT_R4G4_UNORM:
-        case XGL_FMT_R4G4_USCALED:
-        case XGL_FMT_R5G5B5A1_UNORM:
-        case XGL_FMT_R5G5B5A1_USCALED:
-        case XGL_FMT_R5G6B5_UNORM:
-        case XGL_FMT_R5G6B5_USCALED:
-        case XGL_FMT_R64G64B64A64_SFLOAT:
-        case XGL_FMT_R64G64B64_SFLOAT:
-        case XGL_FMT_R64G64_SFLOAT:
-        case XGL_FMT_R64_SFLOAT:
-        case XGL_FMT_R8G8B8A8_SINT:
-        case XGL_FMT_R8G8B8A8_SNORM:
-        case XGL_FMT_R8G8B8A8_SRGB:
-        case XGL_FMT_R8G8B8A8_SSCALED:
-        case XGL_FMT_R8G8B8A8_UINT:
-        case XGL_FMT_R8G8B8A8_UNORM:
-        case XGL_FMT_R8G8B8A8_USCALED:
-        case XGL_FMT_R8G8B8_SINT:
-        case XGL_FMT_R8G8B8_SNORM:
-        case XGL_FMT_R8G8B8_SRGB:
-        case XGL_FMT_R8G8B8_SSCALED:
-        case XGL_FMT_R8G8B8_UINT:
-        case XGL_FMT_R8G8B8_UNORM:
-        case XGL_FMT_R8G8B8_USCALED:
-        case XGL_FMT_R8G8_SINT:
-        case XGL_FMT_R8G8_SNORM:
-        case XGL_FMT_R8G8_SRGB:
-        case XGL_FMT_R8G8_SSCALED:
-        case XGL_FMT_R8G8_UINT:
-        case XGL_FMT_R8G8_UNORM:
-        case XGL_FMT_R8G8_USCALED:
-        case XGL_FMT_R8_SINT:
-        case XGL_FMT_R8_SNORM:
-        case XGL_FMT_R8_SRGB:
-        case XGL_FMT_R8_SSCALED:
-        case XGL_FMT_R8_UINT:
-        case XGL_FMT_R8_UNORM:
-        case XGL_FMT_R8_USCALED:
-        case XGL_FMT_R9G9B9E5_UFLOAT:
-        case XGL_FMT_S8_UINT:
-        case XGL_FMT_UNDEFINED:
+        case XGL_QUERY_OCCLUSION:
+        case XGL_QUERY_PIPELINE_STATISTICS:
             return 1;
         default:
             return 0;
@@ -1061,15 +1007,14 @@ static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
 }
 
 
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 {
-    switch ((XGL_TEX_ADDRESS)input_value)
+    switch ((XGL_QUEUE_FLAGS)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_QUEUE_COMPUTE_BIT:
+        case XGL_QUEUE_DMA_BIT:
+        case XGL_QUEUE_EXTENDED_BIT:
+        case XGL_QUEUE_GRAPHICS_BIT:
             return 1;
         default:
             return 0;
@@ -1077,12 +1022,13 @@ static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 }
 
 
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
 {
-    switch ((XGL_DEPTH_MODE)input_value)
+    switch ((XGL_QUEUE_TYPE)input_value)
     {
-        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
-        case XGL_DEPTH_MODE_ZERO_TO_ONE:
+        case XGL_QUEUE_TYPE_COMPUTE:
+        case XGL_QUEUE_TYPE_DMA:
+        case XGL_QUEUE_TYPE_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -1090,16 +1036,50 @@ static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
 {
-    switch ((XGL_MEMORY_PRIORITY)input_value)
+    switch ((XGL_RESULT)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_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;
@@ -1107,14 +1087,11 @@ static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_va
 }
 
 
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    switch ((XGL_SEMAPHORE_CREATE_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:
+        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
             return 1;
         default:
             return 0;
@@ -1122,14 +1099,17 @@ static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_
 }
 
 
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
 {
-    switch ((XGL_QUEUE_FLAGS)input_value)
+    switch ((XGL_SET_EVENT)input_value)
     {
-        case XGL_QUEUE_COMPUTE_BIT:
-        case XGL_QUEUE_DMA_BIT:
-        case XGL_QUEUE_EXTENDED_BIT:
-        case XGL_QUEUE_GRAPHICS_BIT:
+        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;
@@ -1137,19 +1117,17 @@ static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
 {
-    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+    switch ((XGL_SHADER_STAGE_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:
+        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;
@@ -1157,12 +1135,33 @@ static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS in
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+    switch ((XGL_STATE_BIND_POINT)input_value)
     {
-        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
-        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+        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;
@@ -1236,15 +1235,11 @@ static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_valu
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)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_INFO_TYPE_SUBRESOURCE_LAYOUT:
             return 1;
         default:
             return 0;
@@ -1252,26 +1247,15 @@ static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS
 }
 
 
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
 {
-    switch ((XGL_LOGIC_OP)input_value)
+    switch ((XGL_SYSTEM_ALLOC_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_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;
@@ -1279,11 +1263,15 @@ static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
 }
 
 
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    switch ((XGL_TEX_ADDRESS)input_value)
     {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+        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;
@@ -1291,16 +1279,12 @@ static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_
 }
 
 
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 {
-    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    switch ((XGL_TEX_FILTER)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_TEX_FILTER_LINEAR:
+        case XGL_TEX_FILTER_NEAREST:
             return 1;
         default:
             return 0;
@@ -1308,12 +1292,13 @@ static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_va
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
 {
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    switch ((XGL_TEX_MIPMAP_MODE)input_value)
     {
-        case XGL_PIPELINE_BIND_POINT_COMPUTE:
-        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+        case XGL_TEX_MIPMAP_BASE:
+        case XGL_TEX_MIPMAP_LINEAR:
+        case XGL_TEX_MIPMAP_NEAREST:
             return 1;
         default:
             return 0;
@@ -1321,12 +1306,12 @@ static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT
 }
 
 
-static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
     {
-        case XGL_PROVOKING_VERTEX_FIRST:
-        case XGL_PROVOKING_VERTEX_LAST:
+        case XGL_TIMESTAMP_BOTTOM:
+        case XGL_TIMESTAMP_TOP:
             return 1;
         default:
             return 0;
@@ -1334,14 +1319,15 @@ static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VE
 }
 
 
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
 {
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
+    switch ((XGL_VALIDATION_LEVEL)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_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;
@@ -1349,12 +1335,26 @@ static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_
 }
 
 
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
 {
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
     {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+        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_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;

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 d68bb20..72340ea 100644 (file)
--- 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,102 +3,18 @@
 #include <xgl.h>
 
 
-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_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_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_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_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_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_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
 {
-    switch ((XGL_QUERY_TYPE)input_value)
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
     {
-        case XGL_QUERY_OCCLUSION:
-            return "XGL_QUERY_OCCLUSION";
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return "XGL_QUERY_PIPELINE_STATISTICS";
+        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_QUERY_TYPE";
+            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
     }
 }
 
@@ -119,104 +35,100 @@ static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP
 }
 
 
-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_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_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_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
 {
-    switch ((XGL_IMAGE_ASPECT)input_value)
+    switch ((XGL_BLEND)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_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_IMAGE_ASPECT";
+            return "Unhandled XGL_BLEND";
     }
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 {
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    switch ((XGL_BLEND_FUNC)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_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_DESCRIPTOR_UPDATE_MODE";
+            return "Unhandled XGL_BLEND_FUNC";
     }
 }
 
 
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
 {
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    switch ((XGL_BORDER_COLOR_TYPE)input_value)
     {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+        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_SEMAPHORE_CREATE_FLAGS";
+            return "Unhandled XGL_BORDER_COLOR_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    switch ((XGL_BUFFER_CREATE_FLAGS)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";
+        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_PHYSICAL_GPU_INFO_TYPE";
+            return "Unhandled XGL_BUFFER_CREATE_FLAGS";
     }
 }
 
@@ -259,623 +171,241 @@ static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS i
 }
 
 
-static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
 {
-    switch ((XGL_STRUCTURE_TYPE)input_value)
+    switch ((XGL_BUFFER_VIEW_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_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";
+        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_STATE_BIND_POINT";
+            return "Unhandled XGL_BUFFER_VIEW_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
+static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
 {
-    switch ((XGL_RESULT)input_value)
+    switch ((XGL_CHANNEL_SWIZZLE)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_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_RESULT";
+            return "Unhandled XGL_CHANNEL_SWIZZLE";
     }
 }
 
 
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
 {
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
+    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)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_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_OBJECT_INFO_TYPE";
+            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
 {
-    switch ((XGL_WAIT_EVENT)input_value)
+    switch ((XGL_COMPARE_FUNC)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";
+        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_WAIT_EVENT";
+            return "Unhandled XGL_COMPARE_FUNC";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
 {
-    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+    switch ((XGL_COORDINATE_ORIGIN)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_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_IMAGE_FORMAT_CLASS";
+            return "Unhandled XGL_COORDINATE_ORIGIN";
     }
 }
 
 
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
 {
-    switch ((XGL_TEX_ADDRESS)input_value)
+    switch ((XGL_CULL_MODE)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_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_TEX_ADDRESS";
+            return "Unhandled XGL_CULL_MODE";
     }
 }
 
 
-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_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_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_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_DESCRIPTOR_SET_USAGE";
+            return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
 {
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
     {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+        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_SUBRESOURCE_INFO_TYPE";
+            return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
     }
 }
 
 
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
 {
-    switch ((XGL_STENCIL_OP)input_value)
+    switch ((XGL_DESCRIPTOR_SET_USAGE)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_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_STENCIL_OP";
+            return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
     }
 }
 
 
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
 {
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_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";
+        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_BUFFER_VIEW_TYPE";
+            return "Unhandled XGL_DESCRIPTOR_TYPE";
     }
 }
 
 
-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_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
     {
-        case XGL_PROVOKING_VERTEX_FIRST:
-            return "XGL_PROVOKING_VERTEX_FIRST";
-        case XGL_PROVOKING_VERTEX_LAST:
-            return "XGL_PROVOKING_VERTEX_LAST";
+        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_PROVOKING_VERTEX_CONVENTION";
+            return "Unhandled XGL_DEVICE_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION 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";
-    }
-}
-
-
-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_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)
+    switch ((XGL_FACE_ORIENTATION)input_value)
     {
         case XGL_FRONT_FACE_CCW:
             return "XGL_FRONT_FACE_CCW";
@@ -887,96 +417,6 @@ static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input
 }
 
 
-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)
@@ -993,355 +433,9 @@ static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
 }
 
 
-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)
+static inline const char* string_XGL_FORMAT(XGL_FORMAT 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)
+    switch ((XGL_FORMAT)input_value)
     {
         case XGL_FMT_ASTC_10x10_SRGB:
             return "XGL_FMT_ASTC_10x10_SRGB";
@@ -1678,7 +772,1031 @@ static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
         case XGL_FMT_UNDEFINED:
             return "XGL_FMT_UNDEFINED";
         default:
-            return "Unhandled XGL_FORMAT";
+            return "Unhandled XGL_FORMAT";
+    }
+}
+
+
+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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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";
     }
 }
 
@@ -1699,62 +1817,16 @@ static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_v
 }
 
 
-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_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_LOGIC_OP)input_value)
+    switch ((XGL_TIMESTAMP_TYPE)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_TIMESTAMP_BOTTOM:
+            return "XGL_TIMESTAMP_BOTTOM";
+        case XGL_TIMESTAMP_TOP:
+            return "XGL_TIMESTAMP_TOP";
         default:
-            return "Unhandled XGL_LOGIC_OP";
+            return "Unhandled XGL_TIMESTAMP_TYPE";
     }
 }
 
@@ -1779,104 +1851,32 @@ static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input
 }
 
 
-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_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_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
 {
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)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_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_GPU_COMPATIBILITY_FLAGS";
+            return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
     }
 }
 
 
-static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
 {
-    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+    switch ((XGL_WAIT_EVENT)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_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_MEMORY_INPUT_FLAGS";
+            return "Unhandled XGL_WAIT_EVENT";
     }
 }
 

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 e80a1d1..9327b39 100644 (file)
--- 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,12 +3,13 @@
 #include <xgl.h>
 
 
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
 {
-    switch ((XGL_DEPTH_MODE)input_value)
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
     {
-        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
-        case XGL_DEPTH_MODE_ZERO_TO_ONE:
+        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+        case XGL_ATTACHMENT_LOAD_OP_LOAD:
             return 1;
         default:
             return 0;
@@ -16,14 +17,13 @@ static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
 {
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
     {
-        case XGL_IMAGE_VIEW_1D:
-        case XGL_IMAGE_VIEW_2D:
-        case XGL_IMAGE_VIEW_3D:
-        case XGL_IMAGE_VIEW_CUBE:
+        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;
@@ -31,12 +31,29 @@ static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_va
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
 {
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    switch ((XGL_BLEND)input_value)
     {
-        case XGL_PIPELINE_BIND_POINT_COMPUTE:
-        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+        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;
@@ -44,11 +61,15 @@ static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 {
-    switch ((XGL_MEMORY_REF_FLAGS)input_value)
+    switch ((XGL_BLEND_FUNC)input_value)
     {
-        case XGL_MEMORY_REF_READ_ONLY_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;
@@ -56,11 +77,13 @@ static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
 {
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+    switch ((XGL_BORDER_COLOR_TYPE)input_value)
     {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+        case XGL_BORDER_COLOR_OPAQUE_BLACK:
+        case XGL_BORDER_COLOR_OPAQUE_WHITE:
+        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
             return 1;
         default:
             return 0;
@@ -68,13 +91,12 @@ static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FL
 }
 
 
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
 {
-    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+    switch ((XGL_BUFFER_CREATE_FLAGS)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_BUFFER_CREATE_SHAREABLE_BIT:
+        case XGL_BUFFER_CREATE_SPARSE_BIT:
             return 1;
         default:
             return 0;
@@ -82,12 +104,24 @@ static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP
 }
 
 
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
 {
-    switch ((XGL_QUERY_TYPE)input_value)
+    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
     {
-        case XGL_QUERY_OCCLUSION:
-        case XGL_QUERY_PIPELINE_STATISTICS:
+        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;
@@ -95,13 +129,13 @@ static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
 {
-    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
     {
-        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
-        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
-        case XGL_ATTACHMENT_STORE_OP_STORE:
+        case XGL_BUFFER_VIEW_RAW:
+        case XGL_BUFFER_VIEW_STRUCTURED:
+        case XGL_BUFFER_VIEW_TYPED:
             return 1;
         default:
             return 0;
@@ -109,12 +143,16 @@ static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP
 }
 
 
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
 {
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+    switch ((XGL_CHANNEL_SWIZZLE)input_value)
     {
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
-        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+        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;
@@ -122,12 +160,14 @@ static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_ST
 }
 
 
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
 {
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
+    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
     {
-        case XGL_TIMESTAMP_BOTTOM:
-        case XGL_TIMESTAMP_TOP:
+        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;
@@ -135,12 +175,18 @@ static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_valu
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
 {
-    switch ((XGL_IMAGE_TILING)input_value)
+    switch ((XGL_COMPARE_FUNC)input_value)
     {
-        case XGL_LINEAR_TILING:
-        case XGL_OPTIMAL_TILING:
+        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;
@@ -148,13 +194,12 @@ static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
 {
-    switch ((XGL_IMAGE_ASPECT)input_value)
+    switch ((XGL_COORDINATE_ORIGIN)input_value)
     {
-        case XGL_IMAGE_ASPECT_COLOR:
-        case XGL_IMAGE_ASPECT_DEPTH:
-        case XGL_IMAGE_ASPECT_STENCIL:
+        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
             return 1;
         default:
             return 0;
@@ -162,12 +207,14 @@ static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
 {
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    switch ((XGL_CULL_MODE)input_value)
     {
-        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
-        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+        case XGL_CULL_BACK:
+        case XGL_CULL_FRONT:
+        case XGL_CULL_FRONT_AND_BACK:
+        case XGL_CULL_NONE:
             return 1;
         default:
             return 0;
@@ -175,11 +222,12 @@ static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE
 }
 
 
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    switch ((XGL_DEPTH_MODE)input_value)
     {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+        case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+        case XGL_DEPTH_MODE_ZERO_TO_ONE:
             return 1;
         default:
             return 0;
@@ -187,14 +235,12 @@ static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_
 }
 
 
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)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_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+        case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
             return 1;
         default:
             return 0;
@@ -202,24 +248,12 @@ static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
 {
-    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+    switch ((XGL_DESCRIPTOR_REGION_USAGE)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:
+        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
             return 1;
         default:
             return 0;
@@ -227,65 +261,12 @@ static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS in
 }
 
 
-static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
 {
-    switch ((XGL_STRUCTURE_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_SET_USAGE)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:
+        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
             return 1;
         default:
             return 0;
@@ -293,175 +274,22 @@ static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_valu
 }
 
 
-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_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_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_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_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_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_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)
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
 {
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    switch ((XGL_DESCRIPTOR_TYPE)input_value)
     {
-        case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
-        case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+        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;
@@ -469,11 +297,12 @@ static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAG
 }
 
 
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
 {
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
     {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+        case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+        case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
             return 1;
         default:
             return 0;
@@ -481,18 +310,12 @@ static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_T
 }
 
 
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_STENCIL_OP)input_value)
+    switch ((XGL_DEVICE_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_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+        case XGL_DEVICE_CREATE_VALIDATION_BIT:
             return 1;
         default:
             return 0;
@@ -500,13 +323,12 @@ static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
 {
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    switch ((XGL_FACE_ORIENTATION)input_value)
     {
-        case XGL_BUFFER_VIEW_RAW:
-        case XGL_BUFFER_VIEW_STRUCTURED:
-        case XGL_BUFFER_VIEW_TYPED:
+        case XGL_FRONT_FACE_CCW:
+        case XGL_FRONT_FACE_CW:
             return 1;
         default:
             return 0;
@@ -514,14 +336,13 @@ static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_
 }
 
 
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    switch ((XGL_FILL_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_FILL_POINTS:
+        case XGL_FILL_SOLID:
+        case XGL_FILL_WIREFRAME:
             return 1;
         default:
             return 0;
@@ -529,12 +350,177 @@ static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE inpu
 }
 
 
-static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
 {
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    switch ((XGL_FORMAT)input_value)
     {
-        case XGL_PROVOKING_VERTEX_FIRST:
-        case XGL_PROVOKING_VERTEX_LAST:
+        case XGL_FMT_ASTC_10x10_SRGB:
+        case XGL_FMT_ASTC_10x10_UNORM:
+        case XGL_FMT_ASTC_10x5_SRGB:
+        case XGL_FMT_ASTC_10x5_UNORM:
+        case XGL_FMT_ASTC_10x6_SRGB:
+        case XGL_FMT_ASTC_10x6_UNORM:
+        case XGL_FMT_ASTC_10x8_SRGB:
+        case XGL_FMT_ASTC_10x8_UNORM:
+        case XGL_FMT_ASTC_12x10_SRGB:
+        case XGL_FMT_ASTC_12x10_UNORM:
+        case XGL_FMT_ASTC_12x12_SRGB:
+        case XGL_FMT_ASTC_12x12_UNORM:
+        case XGL_FMT_ASTC_4x4_SRGB:
+        case XGL_FMT_ASTC_4x4_UNORM:
+        case XGL_FMT_ASTC_4x5_SRGB:
+        case XGL_FMT_ASTC_4x5_UNORM:
+        case XGL_FMT_ASTC_5x5_SRGB:
+        case XGL_FMT_ASTC_5x5_UNORM:
+        case XGL_FMT_ASTC_6x5_SRGB:
+        case XGL_FMT_ASTC_6x5_UNORM:
+        case XGL_FMT_ASTC_6x6_SRGB:
+        case XGL_FMT_ASTC_6x6_UNORM:
+        case XGL_FMT_ASTC_8x5_SRGB:
+        case XGL_FMT_ASTC_8x5_UNORM:
+        case XGL_FMT_ASTC_8x6_SRGB:
+        case XGL_FMT_ASTC_8x6_UNORM:
+        case XGL_FMT_ASTC_8x8_SRGB:
+        case XGL_FMT_ASTC_8x8_UNORM:
+        case XGL_FMT_B10G10R10A2_SINT:
+        case XGL_FMT_B10G10R10A2_SNORM:
+        case XGL_FMT_B10G10R10A2_SSCALED:
+        case XGL_FMT_B10G10R10A2_UINT:
+        case XGL_FMT_B10G10R10A2_UNORM:
+        case XGL_FMT_B10G10R10A2_USCALED:
+        case XGL_FMT_B5G6R5_UNORM:
+        case XGL_FMT_B5G6R5_USCALED:
+        case XGL_FMT_B8G8R8A8_SINT:
+        case XGL_FMT_B8G8R8A8_SNORM:
+        case XGL_FMT_B8G8R8A8_SRGB:
+        case XGL_FMT_B8G8R8A8_SSCALED:
+        case XGL_FMT_B8G8R8A8_UINT:
+        case XGL_FMT_B8G8R8A8_UNORM:
+        case XGL_FMT_B8G8R8A8_USCALED:
+        case XGL_FMT_B8G8R8_SINT:
+        case XGL_FMT_B8G8R8_SNORM:
+        case XGL_FMT_B8G8R8_SRGB:
+        case XGL_FMT_B8G8R8_SSCALED:
+        case XGL_FMT_B8G8R8_UINT:
+        case XGL_FMT_B8G8R8_UNORM:
+        case XGL_FMT_B8G8R8_USCALED:
+        case XGL_FMT_BC1_SRGB:
+        case XGL_FMT_BC1_UNORM:
+        case XGL_FMT_BC2_SRGB:
+        case XGL_FMT_BC2_UNORM:
+        case XGL_FMT_BC3_SRGB:
+        case XGL_FMT_BC3_UNORM:
+        case XGL_FMT_BC4_SNORM:
+        case XGL_FMT_BC4_UNORM:
+        case XGL_FMT_BC5_SNORM:
+        case XGL_FMT_BC5_UNORM:
+        case XGL_FMT_BC6H_SFLOAT:
+        case XGL_FMT_BC6H_UFLOAT:
+        case XGL_FMT_BC7_SRGB:
+        case XGL_FMT_BC7_UNORM:
+        case XGL_FMT_D16_UNORM:
+        case XGL_FMT_D16_UNORM_S8_UINT:
+        case XGL_FMT_D24_UNORM:
+        case XGL_FMT_D24_UNORM_S8_UINT:
+        case XGL_FMT_D32_SFLOAT:
+        case XGL_FMT_D32_SFLOAT_S8_UINT:
+        case XGL_FMT_EAC_R11G11_SNORM:
+        case XGL_FMT_EAC_R11G11_UNORM:
+        case XGL_FMT_EAC_R11_SNORM:
+        case XGL_FMT_EAC_R11_UNORM:
+        case XGL_FMT_ETC2_R8G8B8A1_UNORM:
+        case XGL_FMT_ETC2_R8G8B8A8_UNORM:
+        case XGL_FMT_ETC2_R8G8B8_UNORM:
+        case XGL_FMT_R10G10B10A2_SINT:
+        case XGL_FMT_R10G10B10A2_SNORM:
+        case XGL_FMT_R10G10B10A2_SSCALED:
+        case XGL_FMT_R10G10B10A2_UINT:
+        case XGL_FMT_R10G10B10A2_UNORM:
+        case XGL_FMT_R10G10B10A2_USCALED:
+        case XGL_FMT_R11G11B10_UFLOAT:
+        case XGL_FMT_R16G16B16A16_SFLOAT:
+        case XGL_FMT_R16G16B16A16_SINT:
+        case XGL_FMT_R16G16B16A16_SNORM:
+        case XGL_FMT_R16G16B16A16_SSCALED:
+        case XGL_FMT_R16G16B16A16_UINT:
+        case XGL_FMT_R16G16B16A16_UNORM:
+        case XGL_FMT_R16G16B16A16_USCALED:
+        case XGL_FMT_R16G16B16_SFLOAT:
+        case XGL_FMT_R16G16B16_SINT:
+        case XGL_FMT_R16G16B16_SNORM:
+        case XGL_FMT_R16G16B16_SSCALED:
+        case XGL_FMT_R16G16B16_UINT:
+        case XGL_FMT_R16G16B16_UNORM:
+        case XGL_FMT_R16G16B16_USCALED:
+        case XGL_FMT_R16G16_SFLOAT:
+        case XGL_FMT_R16G16_SINT:
+        case XGL_FMT_R16G16_SNORM:
+        case XGL_FMT_R16G16_SSCALED:
+        case XGL_FMT_R16G16_UINT:
+        case XGL_FMT_R16G16_UNORM:
+        case XGL_FMT_R16G16_USCALED:
+        case XGL_FMT_R16_SFLOAT:
+        case XGL_FMT_R16_SINT:
+        case XGL_FMT_R16_SNORM:
+        case XGL_FMT_R16_SSCALED:
+        case XGL_FMT_R16_UINT:
+        case XGL_FMT_R16_UNORM:
+        case XGL_FMT_R16_USCALED:
+        case XGL_FMT_R32G32B32A32_SFLOAT:
+        case XGL_FMT_R32G32B32A32_SINT:
+        case XGL_FMT_R32G32B32A32_UINT:
+        case XGL_FMT_R32G32B32_SFLOAT:
+        case XGL_FMT_R32G32B32_SINT:
+        case XGL_FMT_R32G32B32_UINT:
+        case XGL_FMT_R32G32_SFLOAT:
+        case XGL_FMT_R32G32_SINT:
+        case XGL_FMT_R32G32_UINT:
+        case XGL_FMT_R32_SFLOAT:
+        case XGL_FMT_R32_SINT:
+        case XGL_FMT_R32_UINT:
+        case XGL_FMT_R4G4B4A4_UNORM:
+        case XGL_FMT_R4G4B4A4_USCALED:
+        case XGL_FMT_R4G4_UNORM:
+        case XGL_FMT_R4G4_USCALED:
+        case XGL_FMT_R5G5B5A1_UNORM:
+        case XGL_FMT_R5G5B5A1_USCALED:
+        case XGL_FMT_R5G6B5_UNORM:
+        case XGL_FMT_R5G6B5_USCALED:
+        case XGL_FMT_R64G64B64A64_SFLOAT:
+        case XGL_FMT_R64G64B64_SFLOAT:
+        case XGL_FMT_R64G64_SFLOAT:
+        case XGL_FMT_R64_SFLOAT:
+        case XGL_FMT_R8G8B8A8_SINT:
+        case XGL_FMT_R8G8B8A8_SNORM:
+        case XGL_FMT_R8G8B8A8_SRGB:
+        case XGL_FMT_R8G8B8A8_SSCALED:
+        case XGL_FMT_R8G8B8A8_UINT:
+        case XGL_FMT_R8G8B8A8_UNORM:
+        case XGL_FMT_R8G8B8A8_USCALED:
+        case XGL_FMT_R8G8B8_SINT:
+        case XGL_FMT_R8G8B8_SNORM:
+        case XGL_FMT_R8G8B8_SRGB:
+        case XGL_FMT_R8G8B8_SSCALED:
+        case XGL_FMT_R8G8B8_UINT:
+        case XGL_FMT_R8G8B8_UNORM:
+        case XGL_FMT_R8G8B8_USCALED:
+        case XGL_FMT_R8G8_SINT:
+        case XGL_FMT_R8G8_SNORM:
+        case XGL_FMT_R8G8_SRGB:
+        case XGL_FMT_R8G8_SSCALED:
+        case XGL_FMT_R8G8_UINT:
+        case XGL_FMT_R8G8_UNORM:
+        case XGL_FMT_R8G8_USCALED:
+        case XGL_FMT_R8_SINT:
+        case XGL_FMT_R8_SNORM:
+        case XGL_FMT_R8_SRGB:
+        case XGL_FMT_R8_SSCALED:
+        case XGL_FMT_R8_UINT:
+        case XGL_FMT_R8_UNORM:
+        case XGL_FMT_R8_USCALED:
+        case XGL_FMT_R9G9B9E5_UFLOAT:
+        case XGL_FMT_S8_UINT:
+        case XGL_FMT_UNDEFINED:
             return 1;
         default:
             return 0;
@@ -563,12 +549,11 @@ static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAG
 }
 
 
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
 {
-    switch ((XGL_COORDINATE_ORIGIN)input_value)
+    switch ((XGL_FORMAT_INFO_TYPE)input_value)
     {
-        case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
-        case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
             return 1;
         default:
             return 0;
@@ -576,16 +561,17 @@ static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN inpu
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_MEMORY_PRIORITY)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)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_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;
@@ -593,17 +579,13 @@ static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_va
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 {
-    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+    switch ((XGL_IMAGE_ASPECT)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_IMAGE_ASPECT_COLOR:
+        case XGL_IMAGE_ASPECT_DEPTH:
+        case XGL_IMAGE_ASPECT_STENCIL:
             return 1;
         default:
             return 0;
@@ -611,29 +593,15 @@ static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FL
 }
 
 
-static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_BLEND)input_value)
+    switch ((XGL_IMAGE_CREATE_FLAGS)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:
+        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;
@@ -641,12 +609,28 @@ static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
 {
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
     {
-        case XGL_BUFFER_CREATE_SHAREABLE_BIT:
-        case XGL_BUFFER_CREATE_SPARSE_BIT:
+        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;
@@ -654,12 +638,31 @@ static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS
 }
 
 
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_IMAGE_LAYOUT)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-        case XGL_FRONT_FACE_CW:
+        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_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;
@@ -667,15 +670,13 @@ static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_IMAGE_TYPE)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_IMAGE_1D:
+        case XGL_IMAGE_2D:
+        case XGL_IMAGE_3D:
             return 1;
         default:
             return 0;
@@ -683,13 +684,20 @@ static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
     {
-        case XGL_IMAGE_1D:
-        case XGL_IMAGE_2D:
-        case XGL_IMAGE_3D:
+        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;
@@ -697,13 +705,14 @@ static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
 {
-    switch ((XGL_MEMORY_TYPE)input_value)
+    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
     {
-        case XGL_MEMORY_TYPE_BUFFER:
-        case XGL_MEMORY_TYPE_IMAGE:
-        case XGL_MEMORY_TYPE_OTHER:
+        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;
@@ -711,14 +720,13 @@ static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
 {
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    switch ((XGL_INDEX_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_INDEX_16:
+        case XGL_INDEX_32:
+        case XGL_INDEX_8:
             return 1;
         default:
             return 0;
@@ -726,15 +734,26 @@ static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_
 }
 
 
-static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
 {
-    switch ((XGL_BLEND_FUNC)input_value)
+    switch ((XGL_LOGIC_OP)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_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;
@@ -742,13 +761,19 @@ static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 }
 
 
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
 {
-    switch ((XGL_FILL_MODE)input_value)
+    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
     {
-        case XGL_FILL_POINTS:
-        case XGL_FILL_SOLID:
-        case XGL_FILL_WIREFRAME:
+        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;
@@ -756,12 +781,15 @@ static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
     {
-        case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
-        case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+        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;
@@ -769,11 +797,16 @@ static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGIO
 }
 
 
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
 {
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    switch ((XGL_MEMORY_PRIORITY)input_value)
     {
-        case XGL_QUERY_IMPRECISE_DATA_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;
@@ -781,13 +814,17 @@ static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS
 }
 
 
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
 {
-    switch ((XGL_QUEUE_TYPE)input_value)
+    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
     {
-        case XGL_QUEUE_TYPE_COMPUTE:
-        case XGL_QUEUE_TYPE_DMA:
-        case XGL_QUEUE_TYPE_GRAPHICS:
+        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;
@@ -795,22 +832,11 @@ static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    switch ((XGL_MEMORY_REF_FLAGS)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_MEMORY_REF_READ_ONLY_BIT:
             return 1;
         default:
             return 0;
@@ -818,12 +844,13 @@ static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_va
 }
 
 
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_MEMORY_TYPE)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-        case XGL_TEX_FILTER_NEAREST:
+        case XGL_MEMORY_TYPE_BUFFER:
+        case XGL_MEMORY_TYPE_IMAGE:
+        case XGL_MEMORY_TYPE_OTHER:
             return 1;
         default:
             return 0;
@@ -831,17 +858,14 @@ static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 }
 
 
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
 {
-    switch ((XGL_SET_EVENT)input_value)
+    switch ((XGL_OBJECT_INFO_TYPE)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:
+        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;
@@ -849,15 +873,14 @@ static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
 {
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    switch ((XGL_PHYSICAL_GPU_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:
+        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;
@@ -865,18 +888,14 @@ static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS in
 }
 
 
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
 {
-    switch ((XGL_COMPARE_FUNC)input_value)
+    switch ((XGL_PHYSICAL_GPU_TYPE)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:
+        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;
@@ -884,18 +903,12 @@ static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
 {
-    switch ((XGL_IMAGE_LAYOUT)input_value)
+    switch ((XGL_PIPELINE_BIND_POINT)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_PIPELINE_BIND_POINT_COMPUTE:
+        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -903,17 +916,11 @@ static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
 }
 
 
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    switch ((XGL_PIPELINE_CREATE_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_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
             return 1;
         default:
             return 0;
@@ -938,16 +945,23 @@ static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_ST
 }
 
 
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
 {
-    switch ((XGL_CHANNEL_SWIZZLE)input_value)
+    switch ((XGL_PRIMITIVE_TOPOLOGY)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_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;
@@ -955,13 +969,12 @@ static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_va
 }
 
 
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
 {
-    switch ((XGL_INDEX_TYPE)input_value)
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
     {
-        case XGL_INDEX_16:
-        case XGL_INDEX_32:
-        case XGL_INDEX_8:
+        case XGL_PROVOKING_VERTEX_FIRST:
+        case XGL_PROVOKING_VERTEX_LAST:
             return 1;
         default:
             return 0;
@@ -969,13 +982,11 @@ static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
 {
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
     {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
             return 1;
         default:
             return 0;
@@ -983,13 +994,12 @@ static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP in
 }
 
 
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 {
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    switch ((XGL_QUERY_TYPE)input_value)
     {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+        case XGL_QUERY_OCCLUSION:
+        case XGL_QUERY_PIPELINE_STATISTICS:
             return 1;
         default:
             return 0;
@@ -997,14 +1007,14 @@ static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE inpu
 }
 
 
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 {
-    switch ((XGL_CULL_MODE)input_value)
+    switch ((XGL_QUEUE_FLAGS)input_value)
     {
-        case XGL_CULL_BACK:
-        case XGL_CULL_FRONT:
-        case XGL_CULL_FRONT_AND_BACK:
-        case XGL_CULL_NONE:
+        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;
@@ -1012,12 +1022,13 @@ static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
 }
 
 
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
 {
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    switch ((XGL_QUEUE_TYPE)input_value)
     {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+        case XGL_QUEUE_TYPE_COMPUTE:
+        case XGL_QUEUE_TYPE_DMA:
+        case XGL_QUEUE_TYPE_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -1025,11 +1036,50 @@ static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS
 }
 
 
-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;
@@ -1037,177 +1087,11 @@ static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_
 }
 
 
-static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
-{
-    switch ((XGL_FORMAT)input_value)
-    {
-        case XGL_FMT_ASTC_10x10_SRGB:
-        case XGL_FMT_ASTC_10x10_UNORM:
-        case XGL_FMT_ASTC_10x5_SRGB:
-        case XGL_FMT_ASTC_10x5_UNORM:
-        case XGL_FMT_ASTC_10x6_SRGB:
-        case XGL_FMT_ASTC_10x6_UNORM:
-        case XGL_FMT_ASTC_10x8_SRGB:
-        case XGL_FMT_ASTC_10x8_UNORM:
-        case XGL_FMT_ASTC_12x10_SRGB:
-        case XGL_FMT_ASTC_12x10_UNORM:
-        case XGL_FMT_ASTC_12x12_SRGB:
-        case XGL_FMT_ASTC_12x12_UNORM:
-        case XGL_FMT_ASTC_4x4_SRGB:
-        case XGL_FMT_ASTC_4x4_UNORM:
-        case XGL_FMT_ASTC_4x5_SRGB:
-        case XGL_FMT_ASTC_4x5_UNORM:
-        case XGL_FMT_ASTC_5x5_SRGB:
-        case XGL_FMT_ASTC_5x5_UNORM:
-        case XGL_FMT_ASTC_6x5_SRGB:
-        case XGL_FMT_ASTC_6x5_UNORM:
-        case XGL_FMT_ASTC_6x6_SRGB:
-        case XGL_FMT_ASTC_6x6_UNORM:
-        case XGL_FMT_ASTC_8x5_SRGB:
-        case XGL_FMT_ASTC_8x5_UNORM:
-        case XGL_FMT_ASTC_8x6_SRGB:
-        case XGL_FMT_ASTC_8x6_UNORM:
-        case XGL_FMT_ASTC_8x8_SRGB:
-        case XGL_FMT_ASTC_8x8_UNORM:
-        case XGL_FMT_B10G10R10A2_SINT:
-        case XGL_FMT_B10G10R10A2_SNORM:
-        case XGL_FMT_B10G10R10A2_SSCALED:
-        case XGL_FMT_B10G10R10A2_UINT:
-        case XGL_FMT_B10G10R10A2_UNORM:
-        case XGL_FMT_B10G10R10A2_USCALED:
-        case XGL_FMT_B5G6R5_UNORM:
-        case XGL_FMT_B5G6R5_USCALED:
-        case XGL_FMT_B8G8R8A8_SINT:
-        case XGL_FMT_B8G8R8A8_SNORM:
-        case XGL_FMT_B8G8R8A8_SRGB:
-        case XGL_FMT_B8G8R8A8_SSCALED:
-        case XGL_FMT_B8G8R8A8_UINT:
-        case XGL_FMT_B8G8R8A8_UNORM:
-        case XGL_FMT_B8G8R8A8_USCALED:
-        case XGL_FMT_B8G8R8_SINT:
-        case XGL_FMT_B8G8R8_SNORM:
-        case XGL_FMT_B8G8R8_SRGB:
-        case XGL_FMT_B8G8R8_SSCALED:
-        case XGL_FMT_B8G8R8_UINT:
-        case XGL_FMT_B8G8R8_UNORM:
-        case XGL_FMT_B8G8R8_USCALED:
-        case XGL_FMT_BC1_SRGB:
-        case XGL_FMT_BC1_UNORM:
-        case XGL_FMT_BC2_SRGB:
-        case XGL_FMT_BC2_UNORM:
-        case XGL_FMT_BC3_SRGB:
-        case XGL_FMT_BC3_UNORM:
-        case XGL_FMT_BC4_SNORM:
-        case XGL_FMT_BC4_UNORM:
-        case XGL_FMT_BC5_SNORM:
-        case XGL_FMT_BC5_UNORM:
-        case XGL_FMT_BC6H_SFLOAT:
-        case XGL_FMT_BC6H_UFLOAT:
-        case XGL_FMT_BC7_SRGB:
-        case XGL_FMT_BC7_UNORM:
-        case XGL_FMT_D16_UNORM:
-        case XGL_FMT_D16_UNORM_S8_UINT:
-        case XGL_FMT_D24_UNORM:
-        case XGL_FMT_D24_UNORM_S8_UINT:
-        case XGL_FMT_D32_SFLOAT:
-        case XGL_FMT_D32_SFLOAT_S8_UINT:
-        case XGL_FMT_EAC_R11G11_SNORM:
-        case XGL_FMT_EAC_R11G11_UNORM:
-        case XGL_FMT_EAC_R11_SNORM:
-        case XGL_FMT_EAC_R11_UNORM:
-        case XGL_FMT_ETC2_R8G8B8A1_UNORM:
-        case XGL_FMT_ETC2_R8G8B8A8_UNORM:
-        case XGL_FMT_ETC2_R8G8B8_UNORM:
-        case XGL_FMT_R10G10B10A2_SINT:
-        case XGL_FMT_R10G10B10A2_SNORM:
-        case XGL_FMT_R10G10B10A2_SSCALED:
-        case XGL_FMT_R10G10B10A2_UINT:
-        case XGL_FMT_R10G10B10A2_UNORM:
-        case XGL_FMT_R10G10B10A2_USCALED:
-        case XGL_FMT_R11G11B10_UFLOAT:
-        case XGL_FMT_R16G16B16A16_SFLOAT:
-        case XGL_FMT_R16G16B16A16_SINT:
-        case XGL_FMT_R16G16B16A16_SNORM:
-        case XGL_FMT_R16G16B16A16_SSCALED:
-        case XGL_FMT_R16G16B16A16_UINT:
-        case XGL_FMT_R16G16B16A16_UNORM:
-        case XGL_FMT_R16G16B16A16_USCALED:
-        case XGL_FMT_R16G16B16_SFLOAT:
-        case XGL_FMT_R16G16B16_SINT:
-        case XGL_FMT_R16G16B16_SNORM:
-        case XGL_FMT_R16G16B16_SSCALED:
-        case XGL_FMT_R16G16B16_UINT:
-        case XGL_FMT_R16G16B16_UNORM:
-        case XGL_FMT_R16G16B16_USCALED:
-        case XGL_FMT_R16G16_SFLOAT:
-        case XGL_FMT_R16G16_SINT:
-        case XGL_FMT_R16G16_SNORM:
-        case XGL_FMT_R16G16_SSCALED:
-        case XGL_FMT_R16G16_UINT:
-        case XGL_FMT_R16G16_UNORM:
-        case XGL_FMT_R16G16_USCALED:
-        case XGL_FMT_R16_SFLOAT:
-        case XGL_FMT_R16_SINT:
-        case XGL_FMT_R16_SNORM:
-        case XGL_FMT_R16_SSCALED:
-        case XGL_FMT_R16_UINT:
-        case XGL_FMT_R16_UNORM:
-        case XGL_FMT_R16_USCALED:
-        case XGL_FMT_R32G32B32A32_SFLOAT:
-        case XGL_FMT_R32G32B32A32_SINT:
-        case XGL_FMT_R32G32B32A32_UINT:
-        case XGL_FMT_R32G32B32_SFLOAT:
-        case XGL_FMT_R32G32B32_SINT:
-        case XGL_FMT_R32G32B32_UINT:
-        case XGL_FMT_R32G32_SFLOAT:
-        case XGL_FMT_R32G32_SINT:
-        case XGL_FMT_R32G32_UINT:
-        case XGL_FMT_R32_SFLOAT:
-        case XGL_FMT_R32_SINT:
-        case XGL_FMT_R32_UINT:
-        case XGL_FMT_R4G4B4A4_UNORM:
-        case XGL_FMT_R4G4B4A4_USCALED:
-        case XGL_FMT_R4G4_UNORM:
-        case XGL_FMT_R4G4_USCALED:
-        case XGL_FMT_R5G5B5A1_UNORM:
-        case XGL_FMT_R5G5B5A1_USCALED:
-        case XGL_FMT_R5G6B5_UNORM:
-        case XGL_FMT_R5G6B5_USCALED:
-        case XGL_FMT_R64G64B64A64_SFLOAT:
-        case XGL_FMT_R64G64B64_SFLOAT:
-        case XGL_FMT_R64G64_SFLOAT:
-        case XGL_FMT_R64_SFLOAT:
-        case XGL_FMT_R8G8B8A8_SINT:
-        case XGL_FMT_R8G8B8A8_SNORM:
-        case XGL_FMT_R8G8B8A8_SRGB:
-        case XGL_FMT_R8G8B8A8_SSCALED:
-        case XGL_FMT_R8G8B8A8_UINT:
-        case XGL_FMT_R8G8B8A8_UNORM:
-        case XGL_FMT_R8G8B8A8_USCALED:
-        case XGL_FMT_R8G8B8_SINT:
-        case XGL_FMT_R8G8B8_SNORM:
-        case XGL_FMT_R8G8B8_SRGB:
-        case XGL_FMT_R8G8B8_SSCALED:
-        case XGL_FMT_R8G8B8_UINT:
-        case XGL_FMT_R8G8B8_UNORM:
-        case XGL_FMT_R8G8B8_USCALED:
-        case XGL_FMT_R8G8_SINT:
-        case XGL_FMT_R8G8_SNORM:
-        case XGL_FMT_R8G8_SRGB:
-        case XGL_FMT_R8G8_SSCALED:
-        case XGL_FMT_R8G8_UINT:
-        case XGL_FMT_R8G8_UNORM:
-        case XGL_FMT_R8G8_USCALED:
-        case XGL_FMT_R8_SINT:
-        case XGL_FMT_R8_SNORM:
-        case XGL_FMT_R8_SRGB:
-        case XGL_FMT_R8_SSCALED:
-        case XGL_FMT_R8_UINT:
-        case XGL_FMT_R8_UNORM:
-        case XGL_FMT_R8_USCALED:
-        case XGL_FMT_R9G9B9E5_UFLOAT:
-        case XGL_FMT_S8_UINT:
-        case XGL_FMT_UNDEFINED:
+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;
@@ -1215,13 +1099,17 @@ static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
 }
 
 
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
 {
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
+    switch ((XGL_SET_EVENT)input_value)
     {
-        case XGL_TEX_MIPMAP_BASE:
-        case XGL_TEX_MIPMAP_LINEAR:
-        case XGL_TEX_MIPMAP_NEAREST:
+        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;
@@ -1229,14 +1117,17 @@ static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_va
 }
 
 
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
 {
-    switch ((XGL_QUEUE_FLAGS)input_value)
+    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
     {
-        case XGL_QUEUE_COMPUTE_BIT:
-        case XGL_QUEUE_DMA_BIT:
-        case XGL_QUEUE_EXTENDED_BIT:
-        case XGL_QUEUE_GRAPHICS_BIT:
+        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;
@@ -1244,26 +1135,14 @@ static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 }
 
 
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_LOGIC_OP)input_value)
+    switch ((XGL_STATE_BIND_POINT)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_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;
@@ -1271,15 +1150,18 @@ static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
 }
 
 
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
 {
-    switch ((XGL_VALIDATION_LEVEL)input_value)
+    switch ((XGL_STENCIL_OP)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:
+        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;
@@ -1287,20 +1169,77 @@ static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
 {
-    switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+    switch ((XGL_STRUCTURE_TYPE)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_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_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;
@@ -1324,17 +1263,15 @@ static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE inpu
 }
 
 
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    switch ((XGL_TEX_ADDRESS)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_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;
@@ -1342,19 +1279,82 @@ static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILIT
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 {
-    switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+    switch ((XGL_TEX_FILTER)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_FILTER_LINEAR:
+        case XGL_TEX_FILTER_NEAREST:
+            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_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_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_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_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;

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 a81bb7b..72340ea 100644 (file)
--- 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,66 +3,186 @@
 #include <xgl.h>
 
 
-static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
 {
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    switch ((XGL_ATTACHMENT_LOAD_OP)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_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_PIPELINE_BIND_POINT";
+            return "Unhandled XGL_ATTACHMENT_LOAD_OP";
     }
 }
 
 
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
 {
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    switch ((XGL_ATTACHMENT_STORE_OP)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_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_PIPELINE_SHADER_STAGE";
+            return "Unhandled XGL_ATTACHMENT_STORE_OP";
     }
 }
 
 
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
 {
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+    switch ((XGL_BLEND)input_value)
     {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
-            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
+        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_PIPELINE_CREATE_FLAGS";
+            return "Unhandled XGL_BLEND";
     }
 }
 
 
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 {
-    switch ((XGL_MEMORY_TYPE)input_value)
+    switch ((XGL_BLEND_FUNC)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_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_MEMORY_TYPE";
+            return "Unhandled XGL_BLEND_FUNC";
+    }
+}
+
+
+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_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_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_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";
     }
 }
 
@@ -89,66 +209,276 @@ static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_v
 }
 
 
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
 {
-    switch ((XGL_DEPTH_MODE)input_value)
+    switch ((XGL_CMD_BUFFER_BUILD_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_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_DEPTH_MODE";
+            return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
 {
-    switch ((XGL_FORMAT)input_value)
+    switch ((XGL_COMPARE_FUNC)input_value)
     {
-        case XGL_FMT_ASTC_10x10_SRGB:
-            return "XGL_FMT_ASTC_10x10_SRGB";
-        case XGL_FMT_ASTC_10x10_UNORM:
-            return "XGL_FMT_ASTC_10x10_UNORM";
-        case XGL_FMT_ASTC_10x5_SRGB:
-            return "XGL_FMT_ASTC_10x5_SRGB";
-        case XGL_FMT_ASTC_10x5_UNORM:
-            return "XGL_FMT_ASTC_10x5_UNORM";
-        case XGL_FMT_ASTC_10x6_SRGB:
-            return "XGL_FMT_ASTC_10x6_SRGB";
-        case XGL_FMT_ASTC_10x6_UNORM:
-            return "XGL_FMT_ASTC_10x6_UNORM";
-        case XGL_FMT_ASTC_10x8_SRGB:
-            return "XGL_FMT_ASTC_10x8_SRGB";
-        case XGL_FMT_ASTC_10x8_UNORM:
-            return "XGL_FMT_ASTC_10x8_UNORM";
-        case XGL_FMT_ASTC_12x10_SRGB:
-            return "XGL_FMT_ASTC_12x10_SRGB";
-        case XGL_FMT_ASTC_12x10_UNORM:
-            return "XGL_FMT_ASTC_12x10_UNORM";
-        case XGL_FMT_ASTC_12x12_SRGB:
-            return "XGL_FMT_ASTC_12x12_SRGB";
-        case XGL_FMT_ASTC_12x12_UNORM:
-            return "XGL_FMT_ASTC_12x12_UNORM";
-        case XGL_FMT_ASTC_4x4_SRGB:
-            return "XGL_FMT_ASTC_4x4_SRGB";
-        case XGL_FMT_ASTC_4x4_UNORM:
-            return "XGL_FMT_ASTC_4x4_UNORM";
-        case XGL_FMT_ASTC_4x5_SRGB:
-            return "XGL_FMT_ASTC_4x5_SRGB";
-        case XGL_FMT_ASTC_4x5_UNORM:
-            return "XGL_FMT_ASTC_4x5_UNORM";
-        case XGL_FMT_ASTC_5x5_SRGB:
-            return "XGL_FMT_ASTC_5x5_SRGB";
-        case XGL_FMT_ASTC_5x5_UNORM:
-            return "XGL_FMT_ASTC_5x5_UNORM";
-        case XGL_FMT_ASTC_6x5_SRGB:
-            return "XGL_FMT_ASTC_6x5_SRGB";
-        case XGL_FMT_ASTC_6x5_UNORM:
-            return "XGL_FMT_ASTC_6x5_UNORM";
-        case XGL_FMT_ASTC_6x6_SRGB:
-            return "XGL_FMT_ASTC_6x6_SRGB";
+        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_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_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_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_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_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_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_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_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_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_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_FORMAT(XGL_FORMAT input_value)
+{
+    switch ((XGL_FORMAT)input_value)
+    {
+        case XGL_FMT_ASTC_10x10_SRGB:
+            return "XGL_FMT_ASTC_10x10_SRGB";
+        case XGL_FMT_ASTC_10x10_UNORM:
+            return "XGL_FMT_ASTC_10x10_UNORM";
+        case XGL_FMT_ASTC_10x5_SRGB:
+            return "XGL_FMT_ASTC_10x5_SRGB";
+        case XGL_FMT_ASTC_10x5_UNORM:
+            return "XGL_FMT_ASTC_10x5_UNORM";
+        case XGL_FMT_ASTC_10x6_SRGB:
+            return "XGL_FMT_ASTC_10x6_SRGB";
+        case XGL_FMT_ASTC_10x6_UNORM:
+            return "XGL_FMT_ASTC_10x6_UNORM";
+        case XGL_FMT_ASTC_10x8_SRGB:
+            return "XGL_FMT_ASTC_10x8_SRGB";
+        case XGL_FMT_ASTC_10x8_UNORM:
+            return "XGL_FMT_ASTC_10x8_UNORM";
+        case XGL_FMT_ASTC_12x10_SRGB:
+            return "XGL_FMT_ASTC_12x10_SRGB";
+        case XGL_FMT_ASTC_12x10_UNORM:
+            return "XGL_FMT_ASTC_12x10_UNORM";
+        case XGL_FMT_ASTC_12x12_SRGB:
+            return "XGL_FMT_ASTC_12x12_SRGB";
+        case XGL_FMT_ASTC_12x12_UNORM:
+            return "XGL_FMT_ASTC_12x12_UNORM";
+        case XGL_FMT_ASTC_4x4_SRGB:
+            return "XGL_FMT_ASTC_4x4_SRGB";
+        case XGL_FMT_ASTC_4x4_UNORM:
+            return "XGL_FMT_ASTC_4x4_UNORM";
+        case XGL_FMT_ASTC_4x5_SRGB:
+            return "XGL_FMT_ASTC_4x5_SRGB";
+        case XGL_FMT_ASTC_4x5_UNORM:
+            return "XGL_FMT_ASTC_4x5_UNORM";
+        case XGL_FMT_ASTC_5x5_SRGB:
+            return "XGL_FMT_ASTC_5x5_SRGB";
+        case XGL_FMT_ASTC_5x5_UNORM:
+            return "XGL_FMT_ASTC_5x5_UNORM";
+        case XGL_FMT_ASTC_6x5_SRGB:
+            return "XGL_FMT_ASTC_6x5_SRGB";
+        case XGL_FMT_ASTC_6x5_UNORM:
+            return "XGL_FMT_ASTC_6x5_UNORM";
+        case XGL_FMT_ASTC_6x6_SRGB:
+            return "XGL_FMT_ASTC_6x6_SRGB";
         case XGL_FMT_ASTC_6x6_UNORM:
             return "XGL_FMT_ASTC_6x6_UNORM";
         case XGL_FMT_ASTC_8x5_SRGB:
@@ -447,86 +777,206 @@ static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
 }
 
 
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
 {
-    switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+    switch ((XGL_FORMAT_FEATURE_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";
+        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_BUFFER_CREATE_FLAGS";
+            return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
 {
-    switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+    switch ((XGL_FORMAT_INFO_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_INFO_TYPE_FORMAT_PROPERTIES:
+            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
         default:
-            return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
+            return "Unhandled XGL_FORMAT_INFO_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_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_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_DESCRIPTOR_REGION_USAGE";
+            return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 {
-    switch ((XGL_COORDINATE_ORIGIN)input_value)
+    switch ((XGL_IMAGE_ASPECT)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";
+        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_COORDINATE_ORIGIN";
+            return "Unhandled XGL_IMAGE_ASPECT";
     }
 }
 
 
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_CULL_MODE)input_value)
+    switch ((XGL_IMAGE_CREATE_FLAGS)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";
+        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_CULL_MODE";
+            return "Unhandled XGL_IMAGE_CREATE_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_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_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_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";
     }
 }
 
@@ -561,48 +1011,80 @@ static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS inp
 }
 
 
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
 {
-    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+    switch ((XGL_IMAGE_VIEW_TYPE)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_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_MEMORY_OUTPUT_FLAGS";
+            return "Unhandled XGL_IMAGE_VIEW_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
 {
-    switch ((XGL_SET_EVENT)input_value)
+    switch ((XGL_INDEX_TYPE)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";
-    }
-}
+        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_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_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
@@ -633,152 +1115,68 @@ static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS i
 }
 
 
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
 {
-    switch ((XGL_TEX_MIPMAP_MODE)input_value)
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)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";
+        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_TEX_MIPMAP_MODE";
+            return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
 {
-    switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+    switch ((XGL_MEMORY_PRIORITY)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_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_DESCRIPTOR_UPDATE_MODE";
+            return "Unhandled XGL_MEMORY_PRIORITY";
     }
 }
 
 
-static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
 {
-    switch ((XGL_STRUCTURE_TYPE)input_value)
+    switch ((XGL_MEMORY_PROPERTY_FLAGS)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";
+        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_STRUCTURE_TYPE";
+            return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
     }
 }
 
@@ -795,100 +1193,54 @@ static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input
 }
 
 
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
 {
-    switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+    switch ((XGL_MEMORY_TYPE)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_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_DESCRIPTOR_SET_USAGE";
+            return "Unhandled XGL_MEMORY_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
 {
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    switch ((XGL_OBJECT_INFO_TYPE)input_value)
     {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
-            return "XGL_SEMAPHORE_CREATE_SHAREABLE_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_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";
+            return "Unhandled XGL_OBJECT_INFO_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
 {
-    switch ((XGL_VALIDATION_LEVEL)input_value)
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)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";
+        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_VALIDATION_LEVEL";
+            return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
     }
 }
 
@@ -911,116 +1263,50 @@ static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE inp
 }
 
 
-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_BLEND(XGL_BLEND input_value)
+static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
 {
-    switch ((XGL_BLEND)input_value)
+    switch ((XGL_PIPELINE_BIND_POINT)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";
+        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_BLEND";
+            return "Unhandled XGL_PIPELINE_BIND_POINT";
     }
 }
 
 
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_QUEUE_TYPE)input_value)
+    switch ((XGL_PIPELINE_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_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+            return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
         default:
-            return "Unhandled XGL_QUEUE_TYPE";
+            return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
 {
-    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    switch ((XGL_PIPELINE_SHADER_STAGE)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_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_SHADER_STAGE_FLAGS";
+            return "Unhandled XGL_PIPELINE_SHADER_STAGE";
     }
 }
 
@@ -1061,224 +1347,76 @@ static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY i
 }
 
 
-static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
 {
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)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";
+        case XGL_PROVOKING_VERTEX_FIRST:
+            return "XGL_PROVOKING_VERTEX_FIRST";
+        case XGL_PROVOKING_VERTEX_LAST:
+            return "XGL_PROVOKING_VERTEX_LAST";
         default:
-            return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+            return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_TILING)input_value)
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
     {
-        case XGL_LINEAR_TILING:
-            return "XGL_LINEAR_TILING";
-        case XGL_OPTIMAL_TILING:
-            return "XGL_OPTIMAL_TILING";
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
+            return "XGL_QUERY_IMPRECISE_DATA_BIT";
         default:
-            return "Unhandled XGL_IMAGE_TILING";
+            return "Unhandled XGL_QUERY_CONTROL_FLAGS";
     }
 }
 
 
-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_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 {
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    switch ((XGL_QUEUE_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";
+        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_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";
+            return "Unhandled XGL_QUEUE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
 {
-    switch ((XGL_MEMORY_PRIORITY)input_value)
+    switch ((XGL_QUEUE_TYPE)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";
+        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_MEMORY_PRIORITY";
+            return "Unhandled XGL_QUEUE_TYPE";
     }
 }
 
@@ -1373,510 +1511,372 @@ static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
 }
 
 
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_FILL_MODE)input_value)
+    switch ((XGL_SEMAPHORE_CREATE_FLAGS)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_SEMAPHORE_CREATE_SHAREABLE_BIT:
+            return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
         default:
-            return "Unhandled XGL_FILL_MODE";
+            return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_SET_EVENT)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-            return "XGL_TEX_FILTER_LINEAR";
-        case XGL_TEX_FILTER_NEAREST:
-            return "XGL_TEX_FILTER_NEAREST";
+        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_TEX_FILTER";
+            return "Unhandled XGL_SET_EVENT";
     }
 }
 
 
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
 {
-    switch ((XGL_QUERY_TYPE)input_value)
+    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
     {
-        case XGL_QUERY_OCCLUSION:
-            return "XGL_QUERY_OCCLUSION";
-        case XGL_QUERY_PIPELINE_STATISTICS:
-            return "XGL_QUERY_PIPELINE_STATISTICS";
+        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_QUERY_TYPE";
+            return "Unhandled XGL_SHADER_STAGE_FLAGS";
     }
 }
 
 
-static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+    switch ((XGL_STATE_BIND_POINT)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_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_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_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_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";
+        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_INDEX_TYPE";
+            return "Unhandled XGL_STATE_BIND_POINT";
     }
 }
 
 
-static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
 {
-    switch ((XGL_COMPARE_FUNC)input_value)
+    switch ((XGL_STENCIL_OP)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";
+        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_COMPARE_FUNC";
+            return "Unhandled XGL_STENCIL_OP";
     }
 }
 
 
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
 {
-    switch ((XGL_STATE_BIND_POINT)input_value)
+    switch ((XGL_STRUCTURE_TYPE)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_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_STATE_BIND_POINT";
+            return "Unhandled XGL_STRUCTURE_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
 {
-    switch ((XGL_STENCIL_OP)input_value)
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)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_INFO_TYPE_SUBRESOURCE_LAYOUT:
+            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
         default:
-            return "Unhandled XGL_STENCIL_OP";
+            return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    switch ((XGL_SYSTEM_ALLOC_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";
+        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_PHYSICAL_GPU_INFO_TYPE";
+            return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    switch ((XGL_TEX_ADDRESS)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_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_IMAGE_CREATE_FLAGS";
+            return "Unhandled XGL_TEX_ADDRESS";
     }
 }
 
 
-static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 {
-    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    switch ((XGL_TEX_FILTER)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_TEX_FILTER_LINEAR:
+            return "XGL_TEX_FILTER_LINEAR";
+        case XGL_TEX_FILTER_NEAREST:
+            return "XGL_TEX_FILTER_NEAREST";
         default:
-            return "Unhandled XGL_ATTACHMENT_STORE_OP";
+            return "Unhandled XGL_TEX_FILTER";
     }
 }
 
 
-static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
 {
-    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+    switch ((XGL_TEX_MIPMAP_MODE)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_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_BUFFER_USAGE_FLAGS";
+            return "Unhandled XGL_TEX_MIPMAP_MODE";
     }
 }
 
 
-static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+    switch ((XGL_TIMESTAMP_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";
+        case XGL_TIMESTAMP_BOTTOM:
+            return "XGL_TIMESTAMP_BOTTOM";
+        case XGL_TIMESTAMP_TOP:
+            return "XGL_TIMESTAMP_TOP";
         default:
-            return "Unhandled XGL_IMAGE_VIEW_TYPE";
+            return "Unhandled XGL_TIMESTAMP_TYPE";
     }
 }
 
 
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
 {
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    switch ((XGL_VALIDATION_LEVEL)input_value)
     {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
-            return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+        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_FORMAT_INFO_TYPE";
+            return "Unhandled XGL_VALIDATION_LEVEL";
     }
 }
 
 
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
 {
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
     {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
-            return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+        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_SUBRESOURCE_INFO_TYPE";
+            return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
     }
 }
 
 
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_WAIT_EVENT)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-            return "XGL_FRONT_FACE_CCW";
-        case XGL_FRONT_FACE_CW:
-            return "XGL_FRONT_FACE_CW";
+        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_FACE_ORIENTATION";
+            return "Unhandled XGL_WAIT_EVENT";
     }
 }
 

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 4a0f032..9327b39 100644 (file)
--- 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,12 +3,13 @@
 #include <xgl.h>
 
 
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
 {
-    switch ((XGL_PIPELINE_BIND_POINT)input_value)
+    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
     {
-        case XGL_PIPELINE_BIND_POINT_COMPUTE:
-        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+        case XGL_ATTACHMENT_LOAD_OP_LOAD:
             return 1;
         default:
             return 0;
@@ -16,16 +17,13 @@ static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
 {
-    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+    switch ((XGL_ATTACHMENT_STORE_OP)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_ATTACHMENT_STORE_OP_DONT_CARE:
+        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+        case XGL_ATTACHMENT_STORE_OP_STORE:
             return 1;
         default:
             return 0;
@@ -33,11 +31,29 @@ static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_ST
 }
 
 
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
 {
-    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+    switch ((XGL_BLEND)input_value)
     {
-        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+        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;
@@ -45,13 +61,81 @@ static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FL
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 {
-    switch ((XGL_MEMORY_TYPE)input_value)
+    switch ((XGL_BLEND_FUNC)input_value)
     {
-        case XGL_MEMORY_TYPE_BUFFER:
-        case XGL_MEMORY_TYPE_IMAGE:
-        case XGL_MEMORY_TYPE_OTHER:
+        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_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_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_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+{
+    switch ((XGL_BUFFER_USAGE_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_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;
@@ -76,6 +160,68 @@ static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_va
 }
 
 
+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_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_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_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 {
     switch ((XGL_DEPTH_MODE)input_value)
@@ -89,76 +235,191 @@ static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
 }
 
 
-static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
 {
-    switch ((XGL_FORMAT)input_value)
+    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
     {
-        case XGL_FMT_ASTC_10x10_SRGB:
-        case XGL_FMT_ASTC_10x10_UNORM:
-        case XGL_FMT_ASTC_10x5_SRGB:
-        case XGL_FMT_ASTC_10x5_UNORM:
-        case XGL_FMT_ASTC_10x6_SRGB:
-        case XGL_FMT_ASTC_10x6_UNORM:
-        case XGL_FMT_ASTC_10x8_SRGB:
-        case XGL_FMT_ASTC_10x8_UNORM:
-        case XGL_FMT_ASTC_12x10_SRGB:
-        case XGL_FMT_ASTC_12x10_UNORM:
-        case XGL_FMT_ASTC_12x12_SRGB:
-        case XGL_FMT_ASTC_12x12_UNORM:
-        case XGL_FMT_ASTC_4x4_SRGB:
-        case XGL_FMT_ASTC_4x4_UNORM:
-        case XGL_FMT_ASTC_4x5_SRGB:
-        case XGL_FMT_ASTC_4x5_UNORM:
-        case XGL_FMT_ASTC_5x5_SRGB:
-        case XGL_FMT_ASTC_5x5_UNORM:
-        case XGL_FMT_ASTC_6x5_SRGB:
-        case XGL_FMT_ASTC_6x5_UNORM:
-        case XGL_FMT_ASTC_6x6_SRGB:
-        case XGL_FMT_ASTC_6x6_UNORM:
-        case XGL_FMT_ASTC_8x5_SRGB:
-        case XGL_FMT_ASTC_8x5_UNORM:
-        case XGL_FMT_ASTC_8x6_SRGB:
-        case XGL_FMT_ASTC_8x6_UNORM:
-        case XGL_FMT_ASTC_8x8_SRGB:
-        case XGL_FMT_ASTC_8x8_UNORM:
-        case XGL_FMT_B10G10R10A2_SINT:
-        case XGL_FMT_B10G10R10A2_SNORM:
-        case XGL_FMT_B10G10R10A2_SSCALED:
-        case XGL_FMT_B10G10R10A2_UINT:
-        case XGL_FMT_B10G10R10A2_UNORM:
-        case XGL_FMT_B10G10R10A2_USCALED:
-        case XGL_FMT_B5G6R5_UNORM:
-        case XGL_FMT_B5G6R5_USCALED:
-        case XGL_FMT_B8G8R8A8_SINT:
-        case XGL_FMT_B8G8R8A8_SNORM:
-        case XGL_FMT_B8G8R8A8_SRGB:
-        case XGL_FMT_B8G8R8A8_SSCALED:
-        case XGL_FMT_B8G8R8A8_UINT:
-        case XGL_FMT_B8G8R8A8_UNORM:
-        case XGL_FMT_B8G8R8A8_USCALED:
-        case XGL_FMT_B8G8R8_SINT:
-        case XGL_FMT_B8G8R8_SNORM:
-        case XGL_FMT_B8G8R8_SRGB:
-        case XGL_FMT_B8G8R8_SSCALED:
-        case XGL_FMT_B8G8R8_UINT:
-        case XGL_FMT_B8G8R8_UNORM:
-        case XGL_FMT_B8G8R8_USCALED:
-        case XGL_FMT_BC1_SRGB:
-        case XGL_FMT_BC1_UNORM:
-        case XGL_FMT_BC2_SRGB:
-        case XGL_FMT_BC2_UNORM:
-        case XGL_FMT_BC3_SRGB:
-        case XGL_FMT_BC3_UNORM:
-        case XGL_FMT_BC4_SNORM:
-        case XGL_FMT_BC4_UNORM:
-        case XGL_FMT_BC5_SNORM:
-        case XGL_FMT_BC5_UNORM:
-        case XGL_FMT_BC6H_SFLOAT:
-        case XGL_FMT_BC6H_UFLOAT:
-        case XGL_FMT_BC7_SRGB:
-        case XGL_FMT_BC7_UNORM:
-        case XGL_FMT_D16_UNORM:
-        case XGL_FMT_D16_UNORM_S8_UINT:
+        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_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_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_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_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_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_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_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_FORMAT(XGL_FORMAT input_value)
+{
+    switch ((XGL_FORMAT)input_value)
+    {
+        case XGL_FMT_ASTC_10x10_SRGB:
+        case XGL_FMT_ASTC_10x10_UNORM:
+        case XGL_FMT_ASTC_10x5_SRGB:
+        case XGL_FMT_ASTC_10x5_UNORM:
+        case XGL_FMT_ASTC_10x6_SRGB:
+        case XGL_FMT_ASTC_10x6_UNORM:
+        case XGL_FMT_ASTC_10x8_SRGB:
+        case XGL_FMT_ASTC_10x8_UNORM:
+        case XGL_FMT_ASTC_12x10_SRGB:
+        case XGL_FMT_ASTC_12x10_UNORM:
+        case XGL_FMT_ASTC_12x12_SRGB:
+        case XGL_FMT_ASTC_12x12_UNORM:
+        case XGL_FMT_ASTC_4x4_SRGB:
+        case XGL_FMT_ASTC_4x4_UNORM:
+        case XGL_FMT_ASTC_4x5_SRGB:
+        case XGL_FMT_ASTC_4x5_UNORM:
+        case XGL_FMT_ASTC_5x5_SRGB:
+        case XGL_FMT_ASTC_5x5_UNORM:
+        case XGL_FMT_ASTC_6x5_SRGB:
+        case XGL_FMT_ASTC_6x5_UNORM:
+        case XGL_FMT_ASTC_6x6_SRGB:
+        case XGL_FMT_ASTC_6x6_UNORM:
+        case XGL_FMT_ASTC_8x5_SRGB:
+        case XGL_FMT_ASTC_8x5_UNORM:
+        case XGL_FMT_ASTC_8x6_SRGB:
+        case XGL_FMT_ASTC_8x6_UNORM:
+        case XGL_FMT_ASTC_8x8_SRGB:
+        case XGL_FMT_ASTC_8x8_UNORM:
+        case XGL_FMT_B10G10R10A2_SINT:
+        case XGL_FMT_B10G10R10A2_SNORM:
+        case XGL_FMT_B10G10R10A2_SSCALED:
+        case XGL_FMT_B10G10R10A2_UINT:
+        case XGL_FMT_B10G10R10A2_UNORM:
+        case XGL_FMT_B10G10R10A2_USCALED:
+        case XGL_FMT_B5G6R5_UNORM:
+        case XGL_FMT_B5G6R5_USCALED:
+        case XGL_FMT_B8G8R8A8_SINT:
+        case XGL_FMT_B8G8R8A8_SNORM:
+        case XGL_FMT_B8G8R8A8_SRGB:
+        case XGL_FMT_B8G8R8A8_SSCALED:
+        case XGL_FMT_B8G8R8A8_UINT:
+        case XGL_FMT_B8G8R8A8_UNORM:
+        case XGL_FMT_B8G8R8A8_USCALED:
+        case XGL_FMT_B8G8R8_SINT:
+        case XGL_FMT_B8G8R8_SNORM:
+        case XGL_FMT_B8G8R8_SRGB:
+        case XGL_FMT_B8G8R8_SSCALED:
+        case XGL_FMT_B8G8R8_UINT:
+        case XGL_FMT_B8G8R8_UNORM:
+        case XGL_FMT_B8G8R8_USCALED:
+        case XGL_FMT_BC1_SRGB:
+        case XGL_FMT_BC1_UNORM:
+        case XGL_FMT_BC2_SRGB:
+        case XGL_FMT_BC2_UNORM:
+        case XGL_FMT_BC3_SRGB:
+        case XGL_FMT_BC3_UNORM:
+        case XGL_FMT_BC4_SNORM:
+        case XGL_FMT_BC4_UNORM:
+        case XGL_FMT_BC5_SNORM:
+        case XGL_FMT_BC5_UNORM:
+        case XGL_FMT_BC6H_SFLOAT:
+        case XGL_FMT_BC6H_UFLOAT:
+        case XGL_FMT_BC7_SRGB:
+        case XGL_FMT_BC7_UNORM:
+        case XGL_FMT_D16_UNORM:
+        case XGL_FMT_D16_UNORM_S8_UINT:
         case XGL_FMT_D24_UNORM:
         case XGL_FMT_D24_UNORM_S8_UINT:
         case XGL_FMT_D32_SFLOAT:
@@ -267,276 +528,20 @@ static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
 }
 
 
-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_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_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_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)
+static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
 {
-    switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
     {
-        case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+        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;
@@ -544,12 +549,11 @@ static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_
 }
 
 
-static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
 {
-    switch ((XGL_WAIT_EVENT)input_value)
+    switch ((XGL_FORMAT_INFO_TYPE)input_value)
     {
-        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
-        case XGL_WAIT_EVENT_TOP_OF_PIPE:
+        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
             return 1;
         default:
             return 0;
@@ -557,14 +561,17 @@ static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
 }
 
 
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
 {
-    switch ((XGL_QUEUE_FLAGS)input_value)
+    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
     {
-        case XGL_QUEUE_COMPUTE_BIT:
-        case XGL_QUEUE_DMA_BIT:
-        case XGL_QUEUE_EXTENDED_BIT:
-        case XGL_QUEUE_GRAPHICS_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;
@@ -572,15 +579,13 @@ static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 }
 
 
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 {
-    switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+    switch ((XGL_IMAGE_ASPECT)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:
+        case XGL_IMAGE_ASPECT_COLOR:
+        case XGL_IMAGE_ASPECT_DEPTH:
+        case XGL_IMAGE_ASPECT_STENCIL:
             return 1;
         default:
             return 0;
@@ -588,15 +593,15 @@ static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE inpu
 }
 
 
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_VALIDATION_LEVEL)input_value)
+    switch ((XGL_IMAGE_CREATE_FLAGS)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:
+        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;
@@ -604,14 +609,28 @@ static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_
 }
 
 
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
     {
-        case XGL_GPU_TYPE_DISCRETE:
-        case XGL_GPU_TYPE_INTEGRATED:
-        case XGL_GPU_TYPE_OTHER:
-        case XGL_GPU_TYPE_VIRTUAL:
+        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;
@@ -638,61 +657,12 @@ static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
 }
 
 
-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_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_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
 {
-    switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+    switch ((XGL_IMAGE_TILING)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_LINEAR_TILING:
+        case XGL_OPTIMAL_TILING:
             return 1;
         default:
             return 0;
@@ -700,23 +670,13 @@ static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS in
 }
 
 
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
 {
-    switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+    switch ((XGL_IMAGE_TYPE)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_IMAGE_1D:
+        case XGL_IMAGE_2D:
+        case XGL_IMAGE_3D:
             return 1;
         default:
             return 0;
@@ -724,12 +684,20 @@ static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY in
 }
 
 
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
 {
-    switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+    switch ((XGL_IMAGE_USAGE_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_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;
@@ -737,12 +705,14 @@ static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_ST
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
 {
-    switch ((XGL_IMAGE_TILING)input_value)
+    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
     {
-        case XGL_LINEAR_TILING:
-        case XGL_OPTIMAL_TILING:
+        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;
@@ -750,13 +720,13 @@ static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
 }
 
 
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
 {
-    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+    switch ((XGL_INDEX_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_INDEX_16:
+        case XGL_INDEX_32:
+        case XGL_INDEX_8:
             return 1;
         default:
             return 0;
@@ -764,12 +734,26 @@ static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP
 }
 
 
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
 {
-    switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+    switch ((XGL_LOGIC_OP)input_value)
     {
-        case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
-        case XGL_DEVICE_CREATE_VALIDATION_BIT:
+        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;
@@ -777,14 +761,19 @@ static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS
 }
 
 
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
 {
-    switch ((XGL_OBJECT_INFO_TYPE)input_value)
+    switch ((XGL_MEMORY_INPUT_FLAGS)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_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;
@@ -792,12 +781,15 @@ static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_
 }
 
 
-static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
 {
-    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+    switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
     {
-        case XGL_PROVOKING_VERTEX_FIRST:
-        case XGL_PROVOKING_VERTEX_LAST:
+        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;
@@ -805,13 +797,16 @@ static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VE
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
 {
-    switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+    switch ((XGL_MEMORY_PRIORITY)input_value)
     {
-        case XGL_BUFFER_VIEW_RAW:
-        case XGL_BUFFER_VIEW_STRUCTURED:
-        case XGL_BUFFER_VIEW_TYPED:
+        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;
@@ -819,22 +814,17 @@ static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_
 }
 
 
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
 {
-    switch ((XGL_DESCRIPTOR_TYPE)input_value)
+    switch ((XGL_MEMORY_PROPERTY_FLAGS)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_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;
@@ -842,13 +832,11 @@ static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_va
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_TYPE)input_value)
+    switch ((XGL_MEMORY_REF_FLAGS)input_value)
     {
-        case XGL_IMAGE_1D:
-        case XGL_IMAGE_2D:
-        case XGL_IMAGE_3D:
+        case XGL_MEMORY_REF_READ_ONLY_BIT:
             return 1;
         default:
             return 0;
@@ -856,15 +844,13 @@ static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
 {
-    switch ((XGL_BLEND_FUNC)input_value)
+    switch ((XGL_MEMORY_TYPE)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_TYPE_BUFFER:
+        case XGL_MEMORY_TYPE_IMAGE:
+        case XGL_MEMORY_TYPE_OTHER:
             return 1;
         default:
             return 0;
@@ -872,17 +858,14 @@ static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
 }
 
 
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
 {
-    switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+    switch ((XGL_OBJECT_INFO_TYPE)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_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;
@@ -890,16 +873,14 @@ static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILIT
 }
 
 
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
 {
-    switch ((XGL_MEMORY_PRIORITY)input_value)
+    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)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_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;
@@ -907,50 +888,14 @@ static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_va
 }
 
 
-static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
 {
-    switch ((XGL_RESULT)input_value)
+    switch ((XGL_PHYSICAL_GPU_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_GPU_TYPE_DISCRETE:
+        case XGL_GPU_TYPE_INTEGRATED:
+        case XGL_GPU_TYPE_OTHER:
+        case XGL_GPU_TYPE_VIRTUAL:
             return 1;
         default:
             return 0;
@@ -958,13 +903,12 @@ static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
 }
 
 
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
 {
-    switch ((XGL_FILL_MODE)input_value)
+    switch ((XGL_PIPELINE_BIND_POINT)input_value)
     {
-        case XGL_FILL_POINTS:
-        case XGL_FILL_SOLID:
-        case XGL_FILL_WIREFRAME:
+        case XGL_PIPELINE_BIND_POINT_COMPUTE:
+        case XGL_PIPELINE_BIND_POINT_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -972,12 +916,11 @@ static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
 }
 
 
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_TEX_FILTER)input_value)
+    switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
     {
-        case XGL_TEX_FILTER_LINEAR:
-        case XGL_TEX_FILTER_NEAREST:
+        case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
             return 1;
         default:
             return 0;
@@ -985,12 +928,16 @@ static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 }
 
 
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
 {
-    switch ((XGL_QUERY_TYPE)input_value)
+    switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
     {
-        case XGL_QUERY_OCCLUSION:
-        case XGL_QUERY_PIPELINE_STATISTICS:
+        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;
@@ -998,20 +945,23 @@ static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
 {
-    switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+    switch ((XGL_PRIMITIVE_TOPOLOGY)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_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;
@@ -1019,12 +969,12 @@ static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAG
 }
 
 
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
 {
-    switch ((XGL_TIMESTAMP_TYPE)input_value)
+    switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
     {
-        case XGL_TIMESTAMP_BOTTOM:
-        case XGL_TIMESTAMP_TOP:
+        case XGL_PROVOKING_VERTEX_FIRST:
+        case XGL_PROVOKING_VERTEX_LAST:
             return 1;
         default:
             return 0;
@@ -1032,13 +982,11 @@ static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_valu
 }
 
 
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
 {
-    switch ((XGL_BORDER_COLOR_TYPE)input_value)
+    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
     {
-        case XGL_BORDER_COLOR_OPAQUE_BLACK:
-        case XGL_BORDER_COLOR_OPAQUE_WHITE:
-        case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+        case XGL_QUERY_IMPRECISE_DATA_BIT:
             return 1;
         default:
             return 0;
@@ -1046,26 +994,12 @@ static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE inpu
 }
 
 
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
 {
-    switch ((XGL_LOGIC_OP)input_value)
+    switch ((XGL_QUERY_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_QUERY_OCCLUSION:
+        case XGL_QUERY_PIPELINE_STATISTICS:
             return 1;
         default:
             return 0;
@@ -1073,11 +1007,14 @@ static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
 }
 
 
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
 {
-    switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+    switch ((XGL_QUEUE_FLAGS)input_value)
     {
-        case XGL_QUERY_IMPRECISE_DATA_BIT:
+        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;
@@ -1085,13 +1022,13 @@ static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
 {
-    switch ((XGL_IMAGE_ASPECT)input_value)
+    switch ((XGL_QUEUE_TYPE)input_value)
     {
-        case XGL_IMAGE_ASPECT_COLOR:
-        case XGL_IMAGE_ASPECT_DEPTH:
-        case XGL_IMAGE_ASPECT_STENCIL:
+        case XGL_QUEUE_TYPE_COMPUTE:
+        case XGL_QUEUE_TYPE_DMA:
+        case XGL_QUEUE_TYPE_GRAPHICS:
             return 1;
         default:
             return 0;
@@ -1099,13 +1036,50 @@ static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
 {
-    switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+    switch ((XGL_RESULT)input_value)
     {
-        case XGL_ATTACHMENT_LOAD_OP_CLEAR:
-        case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
-        case XGL_ATTACHMENT_LOAD_OP_LOAD:
+        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;
@@ -1113,28 +1087,11 @@ static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP in
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
 {
-    switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+    switch ((XGL_SEMAPHORE_CREATE_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_SEMAPHORE_CREATE_SHAREABLE_BIT:
             return 1;
         default:
             return 0;
@@ -1142,15 +1099,17 @@ static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS in
 }
 
 
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
 {
-    switch ((XGL_TEX_ADDRESS)input_value)
+    switch ((XGL_SET_EVENT)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_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;
@@ -1158,14 +1117,17 @@ static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 }
 
 
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
 {
-    switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+    switch ((XGL_SHADER_STAGE_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:
+        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;
@@ -1173,13 +1135,14 @@ static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_
 }
 
 
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
 {
-    switch ((XGL_INDEX_TYPE)input_value)
+    switch ((XGL_STATE_BIND_POINT)input_value)
     {
-        case XGL_INDEX_16:
-        case XGL_INDEX_32:
-        case XGL_INDEX_8:
+        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;
@@ -1187,18 +1150,18 @@ static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
 }
 
 
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
 {
-    switch ((XGL_COMPARE_FUNC)input_value)
+    switch ((XGL_STENCIL_OP)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:
+        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;
@@ -1206,14 +1169,65 @@ static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
 }
 
 
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
 {
-    switch ((XGL_STATE_BIND_POINT)input_value)
+    switch ((XGL_STRUCTURE_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_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;
@@ -1221,18 +1235,11 @@ static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_
 }
 
 
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
 {
-    switch ((XGL_STENCIL_OP)input_value)
+    switch ((XGL_SUBRESOURCE_INFO_TYPE)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_INFO_TYPE_SUBRESOURCE_LAYOUT:
             return 1;
         default:
             return 0;
@@ -1240,14 +1247,15 @@ static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
 }
 
 
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
 {
-    switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+    switch ((XGL_SYSTEM_ALLOC_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_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,15 +1263,15 @@ static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
 {
-    switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+    switch ((XGL_TEX_ADDRESS)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_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;
@@ -1271,13 +1279,12 @@ static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS in
 }
 
 
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
 {
-    switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+    switch ((XGL_TEX_FILTER)input_value)
     {
-        case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
-        case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
-        case XGL_ATTACHMENT_STORE_OP_STORE:
+        case XGL_TEX_FILTER_LINEAR:
+        case XGL_TEX_FILTER_NEAREST:
             return 1;
         default:
             return 0;
@@ -1285,24 +1292,13 @@ static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP
 }
 
 
-static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
 {
-    switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+    switch ((XGL_TEX_MIPMAP_MODE)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:
+        case XGL_TEX_MIPMAP_BASE:
+        case XGL_TEX_MIPMAP_LINEAR:
+        case XGL_TEX_MIPMAP_NEAREST:
             return 1;
         default:
             return 0;
@@ -1310,14 +1306,12 @@ static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS in
 }
 
 
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
 {
-    switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+    switch ((XGL_TIMESTAMP_TYPE)input_value)
     {
-        case XGL_IMAGE_VIEW_1D:
-        case XGL_IMAGE_VIEW_2D:
-        case XGL_IMAGE_VIEW_3D:
-        case XGL_IMAGE_VIEW_CUBE:
+        case XGL_TIMESTAMP_BOTTOM:
+        case XGL_TIMESTAMP_TOP:
             return 1;
         default:
             return 0;
@@ -1325,11 +1319,15 @@ static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_va
 }
 
 
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
 {
-    switch ((XGL_FORMAT_INFO_TYPE)input_value)
+    switch ((XGL_VALIDATION_LEVEL)input_value)
     {
-        case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+        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;
@@ -1337,11 +1335,13 @@ static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_
 }
 
 
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
 {
-    switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+    switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
     {
-        case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+        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;
@@ -1349,12 +1349,12 @@ static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_T
 }
 
 
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
 {
-    switch ((XGL_FACE_ORIENTATION)input_value)
+    switch ((XGL_WAIT_EVENT)input_value)
     {
-        case XGL_FRONT_FACE_CCW:
-        case XGL_FRONT_FACE_CW:
+        case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+        case XGL_WAIT_EVENT_TOP_OF_PIPE:
             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 2c92755..68bbc50 100644 (file)
--- 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,112 +6,112 @@
 // 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_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
 size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* 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_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_copy(const XGL_BUFFER_COPY* pStruct);
+size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
+size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* 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_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
+size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* 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_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_create_info(const XGL_CMD_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_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_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_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_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* 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_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* 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_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_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_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* 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_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
+size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct);
+size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct);
+size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
+size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
+size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
+size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* 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_resolve(const XGL_IMAGE_RESOLVE* pStruct);
 size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
+size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
+size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
+size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* 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_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
+size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
+size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
 size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
+size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
+size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct);
+size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct);
+size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
+size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
+size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
 size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
+size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
+size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
+size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* 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_ia_state_create_info(const XGL_PIPELINE_IA_STATE_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_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* 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_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
+size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_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_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_rect(const XGL_RECT* pStruct);
+size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
+size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
+size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
+size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
+size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
+size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
+size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
+size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* 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_viewport(const XGL_VIEWPORT* pStruct);
 
 
-size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_ALLOC_CALLBACKS);
     }
     return structSize;
 }
@@ -125,847 +125,847 @@ size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
     }
     return structSize;
 }
-size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
+size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_LINK_CONST_BUFFER);
-        structSize += pStruct->bufferSize;
+        structSize = sizeof(XGL_BUFFER_COPY);
     }
     return structSize;
 }
-size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
+size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_UPDATE_SAMPLERS);
-        structSize += pStruct->count*sizeof(XGL_SAMPLER);
+        structSize = sizeof(XGL_BUFFER_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_STENCIL_OP_STATE);
+        structSize = sizeof(XGL_BUFFER_IMAGE_COPY);
     }
     return structSize;
 }
-size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO);
+        structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER);
     }
     return structSize;
 }
-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 structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DEVICE_CREATE_INFO);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->queueRecordCount; i++) {
-            structSize += xgl_size_xgl_device_queue_create_info(&pStruct->pRequestedQueues[i]);
-        }
-        for (i = 0; i < pStruct->extensionCount; i++) {
-            structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppEnabledExtensionNames[i]))));
-        }
+        structSize = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
     }
     return structSize;
 }
-size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* 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_BUFFER_MEMORY_REQUIREMENTS);
+        structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
+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_UPDATE_BUFFERS);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->count; i++) {
-            structSize += (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO*) + xgl_size_xgl_buffer_view_attach_info(pStruct->pBufferViews[i]));
-        }
+        structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
+size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
+        structSize = sizeof(XGL_CHANNEL_MAPPING);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->bindingCount; i++) {
-            structSize += xgl_size_xgl_vertex_input_binding_description(&pStruct->pVertexBindingDescriptions[i]);
-        }
-        for (i = 0; i < pStruct->attributeCount; i++) {
-            structSize += xgl_size_xgl_vertex_input_attribute_description(&pStruct->pVertexAttributeDescriptions[i]);
-        }
+        structSize = sizeof(XGL_CLEAR_COLOR);
     }
     return structSize;
 }
-size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_CLEAR_COLOR_VALUE);
     }
     return structSize;
 }
-size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* 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_SUBRESOURCE_LAYOUT);
+        structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
+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_DRAW_INDEXED_INDIRECT_CMD);
+        structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
+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_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]);
-        }
+        structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
+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_SHADER_CREATE_INFO);
-        structSize += pStruct->codeSize;
+        structSize = sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* 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_MEMORY_REF);
+        structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+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_FORMAT_PROPERTIES);
+        structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+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_PIPELINE_STATISTICS_DATA);
+        structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
+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_ALLOC_CALLBACKS);
+        structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
+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_PIPELINE_CB_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
         uint32_t i = 0;
-        for (i = 0; i < pStruct->attachmentCount; i++) {
-            structSize += xgl_size_xgl_pipeline_cb_attachment_state(&pStruct->pAttachments[i]);
+        for (i = 0; i < pStruct->count; i++) {
+            structSize += xgl_size_xgl_descriptor_type_count(&pStruct->pTypeCount[i]);
         }
     }
     return structSize;
 }
-size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
+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_DRAW_INDIRECT_CMD);
+        structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO);
+        structSize = sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
+size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
+        structSize = sizeof(XGL_DEVICE_CREATE_INFO);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->queueRecordCount; i++) {
+            structSize += xgl_size_xgl_device_queue_create_info(&pStruct->pRequestedQueues[i]);
+        }
+        for (i = 0; i < pStruct->extensionCount; i++) {
+            structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppEnabledExtensionNames[i]))));
+        }
     }
     return structSize;
 }
-size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
+        structSize = sizeof(XGL_DEVICE_QUEUE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
+        structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD);
     }
     return structSize;
 }
-size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
+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_FENCE_CREATE_INFO);
+        structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD);
     }
     return structSize;
 }
-size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_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_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);
+        structSize = sizeof(XGL_DRAW_INDIRECT_CMD);
     }
     return structSize;
 }
-size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct)
+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_EXTENT2D);
+        structSize = sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
+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_COMPUTE_PIPELINE_CREATE_INFO);
+        structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* 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_IMAGE_SUBRESOURCE_RANGE);
+        structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
     }
     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_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
+        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_offset2d(const XGL_OFFSET2D* pStruct)
+size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_OFFSET2D);
+        structSize = sizeof(XGL_EVENT_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO);
+        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_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_CLEAR_COLOR_VALUE);
+        structSize = sizeof(XGL_EXTENT2D);
     }
     return structSize;
 }
-size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
+size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER);
+        structSize = sizeof(XGL_EXTENT3D);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_FENCE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_FORMAT_PROPERTIES);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_CREATE_INFO);
+        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_update_images(const XGL_UPDATE_IMAGES* pStruct)
+size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_UPDATE_IMAGES);
-        uint32_t i = 0;
-        for (i = 0; i < pStruct->count; i++) {
-            structSize += (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO*) + xgl_size_xgl_image_view_attach_info(pStruct->pImageViews[i]));
-        }
+        structSize = sizeof(XGL_GPU_COMPATIBILITY_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* 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_CMD_BUFFER_BEGIN_INFO);
+        structSize = sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
+        structSize = sizeof(XGL_IMAGE_COPY);
     }
     return structSize;
 }
-size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
+        structSize = sizeof(XGL_IMAGE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_rect(const XGL_RECT* pStruct)
+size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_RECT);
+        structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER);
     }
     return structSize;
 }
-size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
+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_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
+        structSize = sizeof(XGL_IMAGE_MEMORY_BIND_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DEVICE_QUEUE_CREATE_INFO);
+        structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
     }
     return structSize;
 }
-size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
+size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_OPEN_INFO);
+        structSize = sizeof(XGL_IMAGE_RESOLVE);
     }
     return structSize;
 }
-size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_UPDATE_AS_COPY);
+        structSize = sizeof(XGL_IMAGE_SUBRESOURCE);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
+size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_COPY);
+        structSize = sizeof(XGL_IMAGE_SUBRESOURCE_RANGE);
     }
     return structSize;
 }
-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 structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_RESOLVE);
+        structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* 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_COLOR_ATTACHMENT_BIND_INFO);
+        structSize = sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_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_DYNAMIC_DS_STATE_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_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER);
+        structSize = sizeof(XGL_LINK_CONST_BUFFER);
+        structSize += pStruct->bufferSize;
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
+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_PIPELINE_DS_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+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_PIPELINE_BARRIER);
-        structSize += pStruct->eventCount*sizeof(XGL_SET_EVENT);
-        structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
+        structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
+size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES);
+        structSize = sizeof(XGL_MEMORY_ALLOC_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
+        structSize = sizeof(XGL_MEMORY_BARRIER);
     }
     return structSize;
 }
-size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
+size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* 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]);
-        }
+        structSize = sizeof(XGL_MEMORY_OPEN_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO);
+        structSize = sizeof(XGL_MEMORY_REF);
     }
     return structSize;
 }
-size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
+size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
+        structSize = sizeof(XGL_MEMORY_REQUIREMENTS);
     }
     return structSize;
 }
-size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD);
+        structSize = sizeof(XGL_OFFSET2D);
     }
     return structSize;
 }
-size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* 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]);
-        }
+        structSize = sizeof(XGL_OFFSET3D);
     }
     return structSize;
 }
-size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct)
+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_VIEWPORT);
+        structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO);
     }
     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_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO);
+        structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
+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_QUERY_POOL_CREATE_INFO);
+        structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES);
     }
     return structSize;
 }
-size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO);
+        structSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
     }
     return structSize;
 }
-size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO);
+        structSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
     }
     return structSize;
 }
-size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
+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_MEMORY_REQUIREMENTS);
+        structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
     }
     return structSize;
 }
-size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO);
+        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 xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_MEMORY_BARRIER);
+        structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
     }
     return structSize;
 }
-size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
+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_PHYSICAL_GPU_PERFORMANCE);
+        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_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
+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_CHANNEL_MAPPING);
+        structSize = sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* 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_CLEAR_COLOR);
+        structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
+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_DYNAMIC_CB_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
+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_BUFFER_VIEW_CREATE_INFO);
+        structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_SAMPLER_CREATE_INFO);
+        structSize = sizeof(XGL_PIPELINE_SHADER);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->linkConstBufferCount; i++) {
+            structSize += xgl_size_xgl_link_const_buffer(&pStruct->pLinkConstBufferInfo[i]);
+        }
     }
     return structSize;
 }
-size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
+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_EVENT_WAIT_INFO);
-        structSize += pStruct->eventCount*sizeof(XGL_EVENT);
-        structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
+        structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
+size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_IMAGE_COPY);
+        structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA);
     }
     return structSize;
 }
-size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
+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_EVENT_CREATE_INFO);
+        structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
+size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+        structSize = sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->bindingCount; i++) {
+            structSize += xgl_size_xgl_vertex_input_binding_description(&pStruct->pVertexBindingDescriptions[i]);
+        }
+        for (i = 0; i < pStruct->attributeCount; i++) {
+            structSize += xgl_size_xgl_vertex_input_attribute_description(&pStruct->pVertexAttributeDescriptions[i]);
+        }
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_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_IMAGE_VIEW_ATTACH_INFO);
+        structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
+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_MEMORY_ALLOC_BUFFER_INFO);
+        structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
+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_BUFFER_COPY);
+        structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
+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_IMAGE_MEMORY_BIND_INFO);
+        structSize = sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+size_t xgl_size_xgl_rect(const XGL_RECT* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+        structSize = sizeof(XGL_RECT);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
+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_PIPELINE_SHADER);
+        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->linkConstBufferCount; i++) {
-            structSize += xgl_size_xgl_link_const_buffer(&pStruct->pLinkConstBufferInfo[i]);
+        for (i = 0; i < pStruct->colorAttachmentCount; i++) {
+            structSize += xgl_size_xgl_clear_color(&pStruct->pColorLoadClearValues[i]);
         }
     }
     return structSize;
 }
-size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct)
+size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_OFFSET3D);
+        structSize = sizeof(XGL_SAMPLER_CREATE_INFO);
     }
     return structSize;
 }
-size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* 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_BUFFER_VIEW_ATTACH_INFO);
+        structSize = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO);
+        structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView);
     }
     return structSize;
 }
-size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct)
+size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_EXTENT3D);
+        structSize = sizeof(XGL_SHADER_CREATE_INFO);
+        structSize += pStruct->codeSize;
     }
     return structSize;
 }
-size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
+size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO);
-        structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView);
+        structSize = sizeof(XGL_STENCIL_OP_STATE);
     }
     return structSize;
 }
-size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
+size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_IMAGE_SUBRESOURCE);
+        structSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
     }
     return structSize;
 }
-size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        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]))));
-        }
+        structSize = sizeof(XGL_UPDATE_AS_COPY);
     }
     return structSize;
 }
-size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
+        structSize = sizeof(XGL_UPDATE_BUFFERS);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->count; i++) {
+            structSize += (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO*) + xgl_size_xgl_buffer_view_attach_info(pStruct->pBufferViews[i]));
+        }
     }
     return structSize;
 }
-size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_BUFFER_CREATE_INFO);
+        structSize = sizeof(XGL_UPDATE_IMAGES);
+        uint32_t i = 0;
+        for (i = 0; i < pStruct->count; i++) {
+            structSize += (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO*) + xgl_size_xgl_image_view_attach_info(pStruct->pImageViews[i]));
+        }
     }
     return structSize;
 }
-size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* 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]);
-        }
+        structSize = sizeof(XGL_UPDATE_SAMPLERS);
+        structSize += pStruct->count*sizeof(XGL_SAMPLER);
     }
     return structSize;
 }
-size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
+        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_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* 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_GPU_COMPATIBILITY_INFO);
+        structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
     }
     return structSize;
 }
-size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
+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_MEMORY_ALLOC_INFO);
+        structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
     }
     return structSize;
 }
-size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
+size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct)
 {
     size_t structSize = 0;
     if (pStruct) {
-        structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
+        structSize = sizeof(XGL_VIEWPORT);
     }
     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 7cf0102..056446a 100644 (file)
--- 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,34 +115,13 @@ char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix);
 #define snprintf _snprintf
 #endif // _WIN32
 
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* 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;
+    len = 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);
+    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_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
@@ -175,16 +154,16 @@ char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
+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, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData));
+    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_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -204,7 +183,7 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const ch
         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));
+    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]));
@@ -214,25 +193,40 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const ch
     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* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* 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[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, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
+    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_device_create_info(const XGL_DEVICE_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;
@@ -240,7 +234,7 @@ char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, co
     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);
@@ -250,18 +244,10 @@ char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, co
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -279,7 +265,7 @@ char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREME
     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* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -287,7 +273,7 @@ char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char
     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);
@@ -297,18 +283,10 @@ char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char
     }
     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", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view));
+    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]);
@@ -317,16 +295,7 @@ char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char
     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* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -334,7 +303,7 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -344,26 +313,14 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_
     }
     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;
+    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%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--) {
+    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]);
@@ -372,7 +329,16 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_
     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* 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;
@@ -381,18 +347,13 @@ char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREA
     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] = "";
+    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, "%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));
+    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]));
@@ -402,25 +363,16 @@ char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    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_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* 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, "%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));
+    snprintf(str, len, "%sfloatColor = %p\n%srawColor = %p\n", prefix, (void*)(pStruct->floatColor), prefix, (void*)(pStruct->rawColor));
     return str;
 }
-char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* 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;
@@ -428,7 +380,7 @@ char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREA
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[1];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -438,26 +390,10 @@ char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREA
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -466,7 +402,7 @@ char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -486,7 +422,7 @@ char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, co
         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, "%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]));
@@ -496,43 +432,7 @@ char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, co
     free(extra_indent);
     return str;
 }
-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* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -540,7 +440,7 @@ char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CR
     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);
@@ -550,18 +450,10 @@ char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CR
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -570,13 +462,13 @@ char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+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, "%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, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
     return str;
 }
 char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
@@ -613,25 +505,7 @@ char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT
     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* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -649,13 +523,13 @@ char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, 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, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr);
+    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%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
+    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]));
@@ -665,7 +539,16 @@ char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
+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_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -673,7 +556,7 @@ char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, cons
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -683,10 +566,14 @@ char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, cons
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -695,7 +582,7 @@ char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, cons
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -703,7 +590,7 @@ char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* p
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -713,26 +600,18 @@ char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* p
     }
     else
         stp_strs[0] = "";
-    if (pStruct->pColorAttachments) {
-        tmpStr = xgl_print_xgl_color_attachment_bind_info(pStruct->pColorAttachments, extra_indent);
+    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, " %spColorAttachments (%p)\n%s", prefix, (void*)pStruct->pColorAttachments, tmpStr);
+        snprintf(stp_strs[1], len, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, tmpStr);
     }
     else
         stp_strs[1] = "";
-    if (pStruct->pDepthStencilAttachment) {
-        tmpStr = xgl_print_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[2] = (char*)malloc(len);
-        snprintf(stp_strs[2], len, " %spDepthStencilAttachment (%p)\n%s", prefix, (void*)pStruct->pDepthStencilAttachment, tmpStr);
-    }
-    else
-        stp_strs[2] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    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%scolorAttachmentCount = %u\n%spColorAttachments = %p\n%spDepthStencilAttachment = %p\n%ssampleCount = %u\n%swidth = %u\n%sheight = %u\n%slayers = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorAttachments), prefix, (void*)(pStruct->pDepthStencilAttachment), prefix, (pStruct->sampleCount), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->layers));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+    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]);
@@ -741,16 +620,7 @@ char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* p
     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_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_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;
@@ -758,7 +628,7 @@ char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREA
     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);
@@ -768,14 +638,10 @@ char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREA
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]));
             free(stp_strs[stp_index]);
@@ -784,16 +650,16 @@ char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
+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, "%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));
+    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_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -801,7 +667,7 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -811,10 +677,18 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -823,16 +697,43 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+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, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+    snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
     return str;
 }
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+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_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    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_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_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -852,7 +753,7 @@ char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE
         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%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]));
@@ -862,16 +763,7 @@ char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE
     free(extra_indent);
     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_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
+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;
@@ -891,7 +783,7 @@ char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStru
         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));
+    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]));
@@ -901,7 +793,7 @@ char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStru
     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* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -921,7 +813,7 @@ char* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CR
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssamples = %u\n%smultisampleEnable = %s\n%ssampleShadingEnable = %s\n%sminSampleShading = %f\n%ssampleMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->samples), prefix, (pStruct->multisampleEnable) ? "TRUE" : "FALSE", prefix, (pStruct->sampleShadingEnable) ? "TRUE" : "FALSE", prefix, (pStruct->minSampleShading), prefix, (pStruct->sampleMask));
+    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]));
@@ -931,7 +823,7 @@ char* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CR
     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* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -939,7 +831,7 @@ char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CR
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[3];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -949,10 +841,26 @@ char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CR
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%sprogramPointSize = %s\n%spointOrigin = %s\n%sprovokingVertex = %s\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->programPointSize) ? "TRUE" : "FALSE", prefix, string_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin), prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+    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]);
@@ -961,7 +869,7 @@ char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -969,7 +877,7 @@ char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, cons
     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);
@@ -979,14 +887,10 @@ char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, cons
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -995,7 +899,7 @@ char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, cons
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
+char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1003,7 +907,7 @@ char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char*
     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);
@@ -1013,18 +917,10 @@ char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char*
     }
     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;
+    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%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%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]);
@@ -1033,7 +929,25 @@ char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char*
     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_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_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_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1063,7 +977,16 @@ char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStru
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
+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_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1081,17 +1004,25 @@ char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pSt
     }
     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);
-    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %ssubresourceRange (%p)\n%s", prefix, (void*)&pStruct->subresourceRange, tmpStr);
+    if (pStruct->pColorAttachments) {
+        tmpStr = xgl_print_xgl_color_attachment_bind_info(pStruct->pColorAttachments, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spColorAttachments (%p)\n%s", prefix, (void*)pStruct->pColorAttachments, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    if (pStruct->pDepthStencilAttachment) {
+        tmpStr = xgl_print_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[2] = (char*)malloc(len);
+        snprintf(stp_strs[2], len, " %spDepthStencilAttachment (%p)\n%s", prefix, (void*)pStruct->pDepthStencilAttachment, 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%simage = %p\n%sviewType = %s\n%sformat = %s\n%schannels = %p\n%ssubresourceRange = %p\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)&(pStruct->subresourceRange), prefix, (pStruct->minLod));
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scolorAttachmentCount = %u\n%spColorAttachments = %p\n%spDepthStencilAttachment = %p\n%ssampleCount = %u\n%swidth = %u\n%sheight = %u\n%slayers = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorAttachments), prefix, (void*)(pStruct->pDepthStencilAttachment), prefix, (pStruct->sampleCount), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->layers));
     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]));
@@ -1101,6 +1032,15 @@ char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pSt
     free(extra_indent);
     return str;
 }
+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, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+    return str;
+}
 char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1131,7 +1071,7 @@ char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1139,49 +1079,31 @@ char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
     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);
+    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, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
-    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+    snprintf(stp_strs[0], len, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr);
+    tmpStr = xgl_print_xgl_offset3d(&pStruct->srcOffset, 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;
+    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_offset3d(&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_extent3d(&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, "%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--) {
+    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]);
@@ -1190,16 +1112,7 @@ char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS
     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* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1207,7 +1120,7 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1217,10 +1130,14 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -1229,7 +1146,7 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1237,7 +1154,7 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1247,10 +1164,14 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %ssubresourceRange (%p)\n%s", prefix, (void*)&pStruct->subresourceRange, 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%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--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n%soldLayout = %s\n%snewLayout = %s\n%simage = %p\n%ssubresourceRange = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, string_XGL_IMAGE_LAYOUT(pStruct->oldLayout), prefix, string_XGL_IMAGE_LAYOUT(pStruct->newLayout), prefix, (void*)(pStruct->image), prefix, (void*)&(pStruct->subresourceRange));
+    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]);
@@ -1259,7 +1180,7 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1267,31 +1188,23 @@ char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix
     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);
+    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, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr);
-    tmpStr = xgl_print_xgl_offset3d(&pStruct->srcOffset, extra_indent);
+    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, " %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_offset3d(&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);
+    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[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;
+    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, "%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, "%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]);
@@ -1300,6 +1213,15 @@ char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix
     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_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
 {
     char* str;
@@ -1341,16 +1263,25 @@ char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char*
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* 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, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    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_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* 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, "%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_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1370,7 +1301,7 @@ char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREA
         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));
+    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]));
@@ -1380,7 +1311,7 @@ char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1388,7 +1319,7 @@ char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
+    char* stp_strs[3];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1398,14 +1329,18 @@ char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
+    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, " %ssubresourceRange (%p)\n%s", prefix, (void*)&pStruct->subresourceRange, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
+    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %ssubresourceRange (%p)\n%s", prefix, (void*)&pStruct->subresourceRange, tmpStr);
+    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%soutputMask = %u\n%sinputMask = %u\n%soldLayout = %s\n%snewLayout = %s\n%simage = %p\n%ssubresourceRange = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, string_XGL_IMAGE_LAYOUT(pStruct->oldLayout), prefix, string_XGL_IMAGE_LAYOUT(pStruct->newLayout), prefix, (void*)(pStruct->image), prefix, (void*)&(pStruct->subresourceRange));
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sviewType = %s\n%sformat = %s\n%schannels = %p\n%ssubresourceRange = %p\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)&(pStruct->subresourceRange), prefix, (pStruct->minLod));
+    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]);
@@ -1414,7 +1349,7 @@ char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct
     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* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1422,7 +1357,7 @@ char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CR
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[1];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1432,18 +1367,10 @@ char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CR
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->front, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %sfront (%p)\n%s", prefix, (void*)&pStruct->front, tmpStr);
-    tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->back, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %sback (%p)\n%s", prefix, (void*)&pStruct->back, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sformat = %s\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sstencilTestEnable = %s\n%sfront = %p\n%sback = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, (void*)&(pStruct->front), prefix, (void*)&(pStruct->back));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%slayerCount = %u\n%sppActiveLayerNames = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames)[0]);
+    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]);
@@ -1452,7 +1379,16 @@ char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
+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_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1472,7 +1408,7 @@ char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const
         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));
+    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]));
@@ -1482,16 +1418,37 @@ char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_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, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
+    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_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_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;
@@ -1511,7 +1468,7 @@ char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* p
         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%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]));
@@ -1521,7 +1478,7 @@ char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* p
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1529,7 +1486,7 @@ char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* p
     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);
@@ -1539,24 +1496,91 @@ char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* p
     }
     else
         stp_strs[0] = "";
-    if (pStruct->pSamplerImageViews) {
-        tmpStr = xgl_print_xgl_sampler_image_view_info(pStruct->pSamplerImageViews, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spSamplerImageViews (%p)\n%s", prefix, (void*)pStruct->pSamplerImageViews, tmpStr);
+    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_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[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+        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_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_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_offset2d(const XGL_OFFSET2D* 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));
+    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, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplerImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplerImageViews));
-    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);
+    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_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_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
@@ -1589,25 +1613,43 @@ char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStru
     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_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_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+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, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+    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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* 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, "%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_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_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1615,7 +1657,7 @@ char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CR
     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);
@@ -1625,18 +1667,10 @@ char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CR
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -1645,16 +1679,16 @@ char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
+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, "%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));
+    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_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+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;
@@ -1672,13 +1706,17 @@ char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_
     }
     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);
+    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%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));
+    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]));
@@ -1688,7 +1726,7 @@ char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1696,7 +1734,7 @@ char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pSt
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[3];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1706,10 +1744,18 @@ char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pSt
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->front, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %sfront (%p)\n%s", prefix, (void*)&pStruct->front, tmpStr);
+    tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->back, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %sback (%p)\n%s", prefix, (void*)&pStruct->back, tmpStr);
+    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%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sformat = %s\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sstencilTestEnable = %s\n%sfront = %p\n%sback = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, (void*)&(pStruct->front), prefix, (void*)&(pStruct->back));
+    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]);
@@ -1718,7 +1764,7 @@ char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pSt
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_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;
@@ -1738,7 +1784,7 @@ char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pSt
         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));
+    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]));
@@ -1748,25 +1794,7 @@ char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pSt
     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* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1786,7 +1814,7 @@ char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INF
         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%ssamples = %u\n%smultisampleEnable = %s\n%ssampleShadingEnable = %s\n%sminSampleShading = %f\n%ssampleMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->samples), prefix, (pStruct->multisampleEnable) ? "TRUE" : "FALSE", prefix, (pStruct->sampleShadingEnable) ? "TRUE" : "FALSE", prefix, (pStruct->minSampleShading), prefix, (pStruct->sampleMask));
     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]));
@@ -1796,7 +1824,7 @@ char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INF
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1816,50 +1844,7 @@ char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char
         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");
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%sprogramPointSize = %s\n%spointOrigin = %s\n%sprovokingVertex = %s\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->programPointSize) ? "TRUE" : "FALSE", prefix, string_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin), prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace));
     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]));
@@ -1869,7 +1854,7 @@ char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* pref
     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* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1878,18 +1863,17 @@ char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREA
     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->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, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
-        free(tmpStr);
+        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, "%ssType = %s\n%spNext = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->blendConst));
+    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]));
@@ -1899,7 +1883,7 @@ char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
+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;
@@ -1917,13 +1901,13 @@ char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* p
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+    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, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
+    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%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));
+    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]));
@@ -1933,7 +1917,16 @@ char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* p
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+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_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1953,7 +1946,7 @@ char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct,
         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));
+    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]));
@@ -1963,7 +1956,7 @@ char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct,
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
+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;
@@ -1971,7 +1964,7 @@ char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const ch
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[3];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1981,10 +1974,26 @@ char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const ch
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -1993,7 +2002,7 @@ char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const ch
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* 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;
@@ -2001,23 +2010,20 @@ char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, cons
     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;
+    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, "%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--) {
+    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]);
@@ -2026,7 +2032,7 @@ char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, cons
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2046,7 +2052,7 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, cons
         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%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
     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]));
@@ -2056,16 +2062,7 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, cons
     free(extra_indent);
     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_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_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;
@@ -2085,7 +2082,7 @@ char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pSt
         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));
+    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]));
@@ -2095,7 +2092,7 @@ char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pSt
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2115,7 +2112,7 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO*
         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));
+    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]));
@@ -2125,16 +2122,7 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO*
     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, "%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* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2142,23 +2130,19 @@ char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pSt
     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);
+    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, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr);
-    tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
+    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, " %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;
+    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, "%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, "%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]);
@@ -2167,16 +2151,7 @@ char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pSt
     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* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2184,19 +2159,32 @@ char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const ch
     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);
+    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, " %spLinkConstBufferInfo (%p)\n%s", prefix, (void*)pStruct->pLinkConstBufferInfo, tmpStr);
+        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;
+    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, "%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--) {
+    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]);
@@ -2205,16 +2193,7 @@ char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const ch
     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)
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2234,7 +2213,7 @@ char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* p
         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", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view));
+    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]));
@@ -2244,15 +2223,6 @@ char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* p
     free(extra_indent);
     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_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -2282,16 +2252,7 @@ char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* p
     free(extra_indent);
     return str;
 }
-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, "%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)
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2311,7 +2272,7 @@ char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, cons
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%slayerCount = %u\n%sppActiveLayerNames = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames)[0]);
+    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]));
@@ -2321,7 +2282,25 @@ char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, cons
     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_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_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    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_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2341,7 +2320,7 @@ char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CR
         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%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]));
@@ -2351,7 +2330,7 @@ char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2359,7 +2338,7 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, co
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -2369,10 +2348,18 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, co
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -2381,7 +2368,7 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, co
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2389,7 +2376,7 @@ char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* p
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -2399,22 +2386,18 @@ char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* p
     }
     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);
+    if (pStruct->pImageViews) {
+        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], 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);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spImageViews (%p)\n%s", prefix, (void*)pStruct->pImageViews, tmpStr);
     }
     else
-        stp_strs[2] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+        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%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--) {
+    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]);
@@ -2423,7 +2406,7 @@ char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* p
     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_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2443,7 +2426,7 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L
         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%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]));
@@ -2453,16 +2436,7 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L
     free(extra_indent);
     return str;
 }
-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, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2470,7 +2444,7 @@ char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, cons
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -2480,10 +2454,18 @@ char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, cons
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    if (pStruct->pSamplerImageViews) {
+        tmpStr = xgl_print_xgl_sampler_image_view_info(pStruct->pSamplerImageViews, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spSamplerImageViews (%p)\n%s", prefix, (void*)pStruct->pSamplerImageViews, 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%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--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplerImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplerImageViews));
+    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]);
@@ -2492,13 +2474,31 @@ char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, cons
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
+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, "%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");
+    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_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* 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 b792ea2..9461896 100644 (file)
--- 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,34 +115,13 @@ char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix);
 #define snprintf _snprintf
 #endif // _WIN32
 
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* 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;
+    len = 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);
+    snprintf(str, len, "%spUserData = addr\n%spfnAlloc = addr\n%spfnFree = addr\n", prefix, prefix, prefix);
     return str;
 }
 char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
@@ -175,16 +154,16 @@ char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
+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, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix);
+    snprintf(str, len, "%ssrcOffset = addr\n%sdestOffset = addr\n%scopySize = addr\n", prefix, prefix, prefix);
     return str;
 }
-char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -204,7 +183,7 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const ch
         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);
+    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]));
@@ -214,25 +193,40 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const ch
     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* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* 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[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, "%soriginalImage = addr\n", prefix);
+    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_device_create_info(const XGL_DEVICE_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;
@@ -240,7 +234,7 @@ char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, co
     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);
@@ -250,18 +244,10 @@ char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, co
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -279,7 +265,7 @@ char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREME
     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* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -287,7 +273,7 @@ char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char
     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);
@@ -297,18 +283,10 @@ char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char
     }
     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", 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]);
@@ -317,16 +295,7 @@ char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char
     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* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -334,7 +303,7 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -344,26 +313,14 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_
     }
     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;
+    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%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--) {
+    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]);
@@ -372,7 +329,16 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_
     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* 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;
@@ -381,18 +347,13 @@ char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREA
     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] = "";
+    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, "%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));
+    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]));
@@ -402,25 +363,16 @@ char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
-{
-    char* str;
-    size_t len;
-    len = sizeof(char)*1024;
-    str = (char*)malloc(len);
-    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_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* 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, "%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));
+    snprintf(str, len, "%sfloatColor = addr\n%srawColor = addr\n", prefix, prefix);
     return str;
 }
-char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* 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;
@@ -428,7 +380,7 @@ char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREA
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[1];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -438,26 +390,10 @@ char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREA
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -466,7 +402,7 @@ char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -486,7 +422,7 @@ char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, co
         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, "%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]));
@@ -496,43 +432,7 @@ char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, co
     free(extra_indent);
     return str;
 }
-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* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -540,7 +440,7 @@ char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CR
     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);
@@ -550,18 +450,10 @@ char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CR
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -570,13 +462,13 @@ char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+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, "%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, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
     return str;
 }
 char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
@@ -613,25 +505,7 @@ char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT
     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* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -649,13 +523,13 @@ char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, 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, " %sshader (addr)\n%s", prefix, tmpStr);
+    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%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    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]));
@@ -665,7 +539,16 @@ char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
+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_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -673,7 +556,7 @@ char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, cons
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -683,10 +566,14 @@ char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, cons
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -695,7 +582,7 @@ char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, cons
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -703,7 +590,7 @@ char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* p
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -713,26 +600,18 @@ char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* p
     }
     else
         stp_strs[0] = "";
-    if (pStruct->pColorAttachments) {
-        tmpStr = xgl_print_xgl_color_attachment_bind_info(pStruct->pColorAttachments, extra_indent);
+    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, " %spColorAttachments (addr)\n%s", prefix, tmpStr);
+        snprintf(stp_strs[1], len, " %spTypeCount (addr)\n%s", prefix, tmpStr);
     }
     else
         stp_strs[1] = "";
-    if (pStruct->pDepthStencilAttachment) {
-        tmpStr = xgl_print_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[2] = (char*)malloc(len);
-        snprintf(stp_strs[2], len, " %spDepthStencilAttachment (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;
+    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%scolorAttachmentCount = %u\n%spColorAttachments = addr\n%spDepthStencilAttachment = addr\n%ssampleCount = %u\n%swidth = %u\n%sheight = %u\n%slayers = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, (pStruct->sampleCount), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->layers));
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+    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]);
@@ -741,16 +620,7 @@ char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* p
     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_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_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;
@@ -758,7 +628,7 @@ char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREA
     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);
@@ -768,14 +638,10 @@ char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREA
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]));
             free(stp_strs[stp_index]);
@@ -784,16 +650,16 @@ char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
+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, "%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));
+    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_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -801,7 +667,7 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -811,10 +677,18 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -823,16 +697,43 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+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, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+    snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
     return str;
 }
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+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_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    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_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_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -852,7 +753,7 @@ char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE
         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%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]));
@@ -862,16 +763,7 @@ char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE
     free(extra_indent);
     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_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
+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;
@@ -891,7 +783,7 @@ char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStru
         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);
+    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]));
@@ -901,7 +793,7 @@ char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStru
     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* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -921,7 +813,7 @@ char* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CR
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssamples = %u\n%smultisampleEnable = %s\n%ssampleShadingEnable = %s\n%sminSampleShading = %f\n%ssampleMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->samples), prefix, (pStruct->multisampleEnable) ? "TRUE" : "FALSE", prefix, (pStruct->sampleShadingEnable) ? "TRUE" : "FALSE", prefix, (pStruct->minSampleShading), prefix, (pStruct->sampleMask));
+    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]));
@@ -931,7 +823,7 @@ char* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CR
     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* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -939,7 +831,7 @@ char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CR
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[3];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -949,10 +841,26 @@ char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CR
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%sprogramPointSize = %s\n%spointOrigin = %s\n%sprovokingVertex = %s\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->programPointSize) ? "TRUE" : "FALSE", prefix, string_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin), prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+    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]);
@@ -961,7 +869,7 @@ char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -969,7 +877,7 @@ char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, cons
     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);
@@ -979,14 +887,10 @@ char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, cons
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -995,7 +899,7 @@ char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, cons
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
+char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1003,7 +907,7 @@ char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char*
     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);
@@ -1013,18 +917,10 @@ char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char*
     }
     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;
+    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%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%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]);
@@ -1033,7 +929,25 @@ char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char*
     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_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_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_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1063,7 +977,16 @@ char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStru
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
+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_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1081,17 +1004,25 @@ char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pSt
     }
     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);
-    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %ssubresourceRange (addr)\n%s", prefix, tmpStr);
+    if (pStruct->pColorAttachments) {
+        tmpStr = xgl_print_xgl_color_attachment_bind_info(pStruct->pColorAttachments, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spColorAttachments (addr)\n%s", prefix, tmpStr);
+    }
+    else
+        stp_strs[1] = "";
+    if (pStruct->pDepthStencilAttachment) {
+        tmpStr = xgl_print_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[2] = (char*)malloc(len);
+        snprintf(stp_strs[2], len, " %spDepthStencilAttachment (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%simage = addr\n%sviewType = %s\n%sformat = %s\n%schannels = addr\n%ssubresourceRange = addr\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix, (pStruct->minLod));
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scolorAttachmentCount = %u\n%spColorAttachments = addr\n%spDepthStencilAttachment = addr\n%ssampleCount = %u\n%swidth = %u\n%sheight = %u\n%slayers = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, (pStruct->sampleCount), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->layers));
     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]));
@@ -1101,6 +1032,15 @@ char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pSt
     free(extra_indent);
     return str;
 }
+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, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+    return str;
+}
 char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -1131,7 +1071,7 @@ char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1139,49 +1079,31 @@ char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
     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);
+    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, " %soffset (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+    snprintf(stp_strs[0], len, " %ssrcSubresource (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_offset3d(&pStruct->srcOffset, 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;
+    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_offset3d(&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_extent3d(&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, "%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--) {
+    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]);
@@ -1190,16 +1112,7 @@ char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS
     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* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1207,7 +1120,7 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1217,10 +1130,14 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%ssharedMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+    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]);
@@ -1229,7 +1146,7 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1237,7 +1154,7 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1247,10 +1164,14 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %ssubresourceRange (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%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--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n%soldLayout = %s\n%snewLayout = %s\n%simage = addr\n%ssubresourceRange = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, string_XGL_IMAGE_LAYOUT(pStruct->oldLayout), prefix, string_XGL_IMAGE_LAYOUT(pStruct->newLayout), 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]);
@@ -1259,7 +1180,7 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1267,31 +1188,23 @@ char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix
     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);
+    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, " %ssrcSubresource (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_offset3d(&pStruct->srcOffset, extra_indent);
+    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, " %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_offset3d(&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);
+    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[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;
+    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, "%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, "%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]);
@@ -1300,6 +1213,15 @@ char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix
     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_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
 {
     char* str;
@@ -1341,16 +1263,25 @@ char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char*
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* 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, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+    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_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* 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, "%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_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1370,7 +1301,7 @@ char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREA
         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));
+    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]));
@@ -1380,7 +1311,7 @@ char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1388,7 +1319,7 @@ char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[2];
+    char* stp_strs[3];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1398,14 +1329,18 @@ char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
+    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, " %ssubresourceRange (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+    snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %ssubresourceRange (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, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n%soldLayout = %s\n%snewLayout = %s\n%simage = addr\n%ssubresourceRange = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, string_XGL_IMAGE_LAYOUT(pStruct->oldLayout), prefix, string_XGL_IMAGE_LAYOUT(pStruct->newLayout), prefix, prefix);
-    for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sviewType = %s\n%sformat = %s\n%schannels = addr\n%ssubresourceRange = addr\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix, (pStruct->minLod));
+    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]);
@@ -1414,7 +1349,7 @@ char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct
     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* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1422,7 +1357,7 @@ char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CR
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[1];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1432,18 +1367,10 @@ char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CR
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->front, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[1] = (char*)malloc(len);
-    snprintf(stp_strs[1], len, " %sfront (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->back, extra_indent);
-    len = 256+strlen(tmpStr);
-    stp_strs[2] = (char*)malloc(len);
-    snprintf(stp_strs[2], len, " %sback (addr)\n%s", prefix, tmpStr);
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+    len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sformat = %s\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sstencilTestEnable = %s\n%sfront = addr\n%sback = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, prefix);
-    for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%slayerCount = %u\n%sppActiveLayerNames = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames)[0]);
+    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]);
@@ -1452,7 +1379,16 @@ char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
+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_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1472,7 +1408,7 @@ char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const
         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);
+    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]));
@@ -1482,16 +1418,37 @@ char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_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, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
+    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_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_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;
@@ -1511,7 +1468,7 @@ char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* p
         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%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]));
@@ -1521,7 +1478,7 @@ char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* p
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1529,7 +1486,7 @@ char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* p
     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);
@@ -1539,24 +1496,91 @@ char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* p
     }
     else
         stp_strs[0] = "";
-    if (pStruct->pSamplerImageViews) {
-        tmpStr = xgl_print_xgl_sampler_image_view_info(pStruct->pSamplerImageViews, extra_indent);
-        len = 256+strlen(tmpStr)+strlen(prefix);
-        stp_strs[1] = (char*)malloc(len);
-        snprintf(stp_strs[1], len, " %spSamplerImageViews (addr)\n%s", prefix, tmpStr);
+    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_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[1] = "";
-    len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+        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_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_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_offset2d(const XGL_OFFSET2D* 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));
+    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, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplerImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, 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);
+    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_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_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
@@ -1589,25 +1613,43 @@ char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStru
     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_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_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+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, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+    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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* 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, "%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_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_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1615,7 +1657,7 @@ char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CR
     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);
@@ -1625,18 +1667,10 @@ char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CR
     }
     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;
+    len = strlen(stp_strs[0]) + 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--) {
+    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]);
@@ -1645,16 +1679,16 @@ char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
+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, "%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));
+    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_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+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;
@@ -1672,13 +1706,17 @@ char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_
     }
     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);
+    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%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));
+    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]));
@@ -1688,7 +1726,7 @@ char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1696,7 +1734,7 @@ char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pSt
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[3];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1706,10 +1744,18 @@ char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pSt
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->front, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[1] = (char*)malloc(len);
+    snprintf(stp_strs[1], len, " %sfront (addr)\n%s", prefix, tmpStr);
+    tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->back, extra_indent);
+    len = 256+strlen(tmpStr);
+    stp_strs[2] = (char*)malloc(len);
+    snprintf(stp_strs[2], len, " %sback (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, "%ssType = %s\n%spNext = addr\n%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
-    for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sformat = %s\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sstencilTestEnable = %s\n%sfront = addr\n%sback = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", 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]);
@@ -1718,7 +1764,7 @@ char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pSt
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_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;
@@ -1738,7 +1784,7 @@ char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pSt
         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));
+    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]));
@@ -1748,25 +1794,7 @@ char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pSt
     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* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1786,7 +1814,7 @@ char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INF
         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%ssamples = %u\n%smultisampleEnable = %s\n%ssampleShadingEnable = %s\n%sminSampleShading = %f\n%ssampleMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->samples), prefix, (pStruct->multisampleEnable) ? "TRUE" : "FALSE", prefix, (pStruct->sampleShadingEnable) ? "TRUE" : "FALSE", prefix, (pStruct->minSampleShading), prefix, (pStruct->sampleMask));
     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]));
@@ -1796,7 +1824,7 @@ char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INF
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1816,50 +1844,7 @@ char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char
         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");
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%sprogramPointSize = %s\n%spointOrigin = %s\n%sprovokingVertex = %s\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->programPointSize) ? "TRUE" : "FALSE", prefix, string_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin), prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace));
     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]));
@@ -1869,7 +1854,7 @@ char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* pref
     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* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1878,18 +1863,17 @@ char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREA
     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->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, " %spNext (addr)\n%s", prefix, tmpStr);
-        free(tmpStr);
+        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, "%ssType = %s\n%spNext = addr\n%sblendConst = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    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]));
@@ -1899,7 +1883,7 @@ char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREA
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
+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;
@@ -1917,13 +1901,13 @@ char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* p
     }
     else
         stp_strs[0] = "";
-    tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+    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, " %schannels (addr)\n%s", prefix, tmpStr);
+    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%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);
+    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]));
@@ -1933,7 +1917,16 @@ char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* p
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+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_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -1953,7 +1946,7 @@ char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct,
         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));
+    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]));
@@ -1963,7 +1956,7 @@ char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct,
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
+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;
@@ -1971,7 +1964,7 @@ char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const ch
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[3];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -1981,10 +1974,26 @@ char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const ch
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -1993,7 +2002,7 @@ char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const ch
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* 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;
@@ -2001,23 +2010,20 @@ char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, cons
     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;
+    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, "%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--) {
+    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]);
@@ -2026,7 +2032,7 @@ char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, cons
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2046,7 +2052,7 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, cons
         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%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
     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]));
@@ -2056,16 +2062,7 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, cons
     free(extra_indent);
     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_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_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;
@@ -2085,7 +2082,7 @@ char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pSt
         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));
+    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]));
@@ -2095,7 +2092,7 @@ char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pSt
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2115,7 +2112,7 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO*
         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));
+    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]));
@@ -2125,16 +2122,7 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO*
     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, "%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* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2142,23 +2130,19 @@ char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pSt
     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);
+    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, " %ssubresource (addr)\n%s", prefix, tmpStr);
-    tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
+    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, " %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;
+    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, "%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, "%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]);
@@ -2167,16 +2151,7 @@ char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pSt
     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* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2184,19 +2159,32 @@ char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const ch
     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);
+    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, " %spLinkConstBufferInfo (addr)\n%s", prefix, tmpStr);
+        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;
+    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, "%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--) {
+    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]);
@@ -2205,16 +2193,7 @@ char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const ch
     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)
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2234,7 +2213,7 @@ char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* p
         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", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+    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]));
@@ -2244,15 +2223,6 @@ char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* p
     free(extra_indent);
     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_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
 {
     char* str;
@@ -2282,16 +2252,7 @@ char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* p
     free(extra_indent);
     return str;
 }
-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, "%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)
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2311,7 +2272,7 @@ char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, cons
         stp_strs[0] = "";
     len = strlen(stp_strs[0]) + sizeof(char)*1024;
     str = (char*)malloc(len);
-    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%slayerCount = %u\n%sppActiveLayerNames = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames)[0]);
+    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]));
@@ -2321,7 +2282,25 @@ char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, cons
     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_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_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
+{
+    char* str;
+    size_t len;
+    len = sizeof(char)*1024;
+    str = (char*)malloc(len);
+    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_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2341,7 +2320,7 @@ char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CR
         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%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]));
@@ -2351,7 +2330,7 @@ char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CR
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2359,7 +2338,7 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, co
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -2369,10 +2348,18 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, co
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    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%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--) {
+    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]);
@@ -2381,7 +2368,7 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, co
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2389,7 +2376,7 @@ char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* p
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[3];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -2399,22 +2386,18 @@ char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* p
     }
     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);
+    if (pStruct->pImageViews) {
+        tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], 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);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spImageViews (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;
+        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%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--) {
+    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]);
@@ -2423,7 +2406,7 @@ char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* p
     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_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2443,7 +2426,7 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L
         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%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]));
@@ -2453,16 +2436,7 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L
     free(extra_indent);
     return str;
 }
-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, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
-    return str;
-}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
 {
     char* str;
     size_t len;
@@ -2470,7 +2444,7 @@ char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, cons
     char* extra_indent = (char*)malloc(strlen(prefix) + 3);
     strcpy(extra_indent, "  ");
     strncat(extra_indent, prefix, strlen(prefix));
-    char* stp_strs[1];
+    char* stp_strs[2];
     if (pStruct->pNext) {
         tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
         len = 256+strlen(tmpStr);
@@ -2480,10 +2454,18 @@ char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, cons
     }
     else
         stp_strs[0] = "";
-    len = strlen(stp_strs[0]) + sizeof(char)*1024;
+    if (pStruct->pSamplerImageViews) {
+        tmpStr = xgl_print_xgl_sampler_image_view_info(pStruct->pSamplerImageViews, extra_indent);
+        len = 256+strlen(tmpStr)+strlen(prefix);
+        stp_strs[1] = (char*)malloc(len);
+        snprintf(stp_strs[1], len, " %spSamplerImageViews (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%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--) {
+    snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplerImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, 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]);
@@ -2492,13 +2474,31 @@ char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, cons
     free(extra_indent);
     return str;
 }
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
+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, "%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");
+    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_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* 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 e50bd3d..06160db 100644 (file)
--- 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,199 +8,309 @@
 #include "xgl_enum_validate_helper.h"
 
 // Function Prototypes
-uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
 uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* 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_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_copy(const XGL_BUFFER_COPY* pStruct);
+uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
+uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* 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_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* 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_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_create_info(const XGL_CMD_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_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_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_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_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* 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_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* 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_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_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_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* 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_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
+uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct);
+uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct);
+uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
+uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
+uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* 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_resolve(const XGL_IMAGE_RESOLVE* pStruct);
 uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
+uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
+uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
+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);
-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_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
 uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
+uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct);
+uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct);
+uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
 uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
+uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* 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_ia_state_create_info(const XGL_PIPELINE_IA_STATE_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_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* 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_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
+uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_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_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct);
+uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
+uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
+uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
+uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
+uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
+uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
+uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
+uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* 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_viewport(const XGL_VIEWPORT* pStruct);
 
 
-uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology))
+    return 1;
+}
+uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
+{
+    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_application_info(const XGL_APPLICATION_INFO* pStruct)
+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))
+        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_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_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
+uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
+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_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
 {
-    if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp))
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp))
+    if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType))
         return 0;
-    if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp))
+    if (!validate_XGL_FORMAT(pStruct->format))
         return 0;
-    if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc))
+    if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+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_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
+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_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+{
+    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;
-    if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues))
+    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_VALIDATION_LEVEL(pStruct->maxValidationLevel))
+    if (!validate_XGL_QUEUE_TYPE(pStruct->queueType))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
+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_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
+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_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_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_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_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_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_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 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_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
+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_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
+{
+    return 1;
+}
+uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+{
+    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_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* 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)
+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;
-    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)
+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_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
+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;
     return 1;
 }
 uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
@@ -213,109 +323,131 @@ uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STAT
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_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;
     return 1;
 }
-uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* 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_WAIT_EVENT(pStruct->waitEvent))
+        return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct)
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct)
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
+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_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+{
+    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 (!validate_XGL_LOGIC_OP(pStruct->logicOp))
+    if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments))
         return 0;
-    if (pStruct->pAttachments && !xgl_validate_xgl_pipeline_cb_attachment_state((const XGL_PIPELINE_CB_ATTACHMENT_STATE*)pStruct->pAttachments))
+    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_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
+uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
+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;
-    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)
+uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* 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))
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
         return 0;
-    if (!validate_XGL_BLEND(pStruct->srcBlendAlpha))
+    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->srcOffset))
         return 0;
-    if (!validate_XGL_BLEND(pStruct->destBlendAlpha))
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
         return 0;
-    if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha))
+    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->destOffset))
         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))
+    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->shader))
+    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_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
+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_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
 {
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->subresource))
         return 0;
-    if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments))
+    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->offset))
         return 0;
-    if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment))
+    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct)
+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_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
 {
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
         return 0;
-    if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs))
+    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_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
+{
+    if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
         return 0;
     return 1;
 }
@@ -325,185 +457,153 @@ uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RA
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
+    if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
+        return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct)
+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_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_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;
     return 1;
 }
-uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* 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;
     return 1;
 }
-uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
+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_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_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;
-    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))
+    if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
         return 0;
-    if (!validate_XGL_FACE_ORIENTATION(pStruct->frontFace))
+    if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* 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)
+uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* 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)
+uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* 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)
+uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* 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))
+    if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct)
 {
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct)
+uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* 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)
+uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+{
+    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_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
 {
     return 1;
 }
-uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* 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)
+uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
 {
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+    if (!validate_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* 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 1;
+}
+uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+{
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+    if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
+uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
 {
-    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
+    if (!validate_XGL_FORMAT(pStruct->format))
         return 0;
-    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset))
+    if (!validate_XGL_BLEND(pStruct->srcBlendColor))
         return 0;
-    if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
+    if (!validate_XGL_BLEND(pStruct->destBlendColor))
         return 0;
-    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset))
+    if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor))
         return 0;
-    if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
+    if (!validate_XGL_BLEND(pStruct->srcBlendAlpha))
         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))
+    if (!validate_XGL_BLEND(pStruct->destBlendAlpha))
         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))
+    if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+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_IMAGE_LAYOUT(pStruct->oldLayout))
-        return 0;
-    if (!validate_XGL_IMAGE_LAYOUT(pStruct->newLayout))
+    if (!validate_XGL_LOGIC_OP(pStruct->logicOp))
         return 0;
-    if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
+    if (pStruct->pAttachments && !xgl_validate_xgl_pipeline_cb_attachment_state((const XGL_PIPELINE_CB_ATTACHMENT_STATE*)pStruct->pAttachments))
         return 0;
     return 1;
 }
@@ -521,147 +621,125 @@ uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_ST
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+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_WAIT_EVENT(pStruct->waitEvent))
+    if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology))
         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)
+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;
-    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)
+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 (pStruct->pSamplerImageViews && !xgl_validate_xgl_sampler_image_view_info((const XGL_SAMPLER_IMAGE_VIEW_INFO*)pStruct->pSamplerImageViews))
+    if (!validate_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin))
         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))
+    if (!validate_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex))
         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))
+    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_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
+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 (pStruct->pTypeCount && !xgl_validate_xgl_descriptor_type_count((const XGL_DESCRIPTOR_TYPE_COUNT*)pStruct->pTypeCount))
+    if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->shader))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct)
+uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
 {
     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_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_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)
+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 (!validate_XGL_QUERY_TYPE(pStruct->queryType))
+    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_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!validate_XGL_QUEUE_TYPE(pStruct->queueType))
+    if (!validate_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin))
         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))
+    if (!validate_XGL_DEPTH_MODE(pStruct->depthMode))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
+uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
 {
-    if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
+    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_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
+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_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
+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_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
-{
-    return 1;
-}
-uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
+uint32_t xgl_validate_xgl_rect(const XGL_RECT* 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))
+    if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset))
         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))
+    if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_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))
+    if (!xgl_validate_xgl_rect((const XGL_RECT*)&pStruct->renderArea))
         return 0;
-    if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType))
+    if (pStruct->pColorLoadClearValues && !xgl_validate_xgl_clear_color((const XGL_CLEAR_COLOR*)pStruct->pColorLoadClearValues))
         return 0;
-    if (!validate_XGL_FORMAT(pStruct->format))
+    if (!validate_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp))
         return 0;
-    if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
+    if (!validate_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp))
+        return 0;
+    if (!validate_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp))
+        return 0;
+    if (!validate_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp))
         return 0;
     return 1;
 }
@@ -687,167 +765,89 @@ uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pSt
         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_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
-{
-    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_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_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
 {
-    if (!validate_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType))
+    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_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
+uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
-        return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
+uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
 {
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+    if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp))
         return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
-{
-    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))
+    if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp))
         return 0;
-    if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->offset))
+    if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp))
         return 0;
-    if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+    if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* 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)
+uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
 {
-    if (!validate_XGL_PIPELINE_SHADER_STAGE(pStruct->stage))
+    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (pStruct->pLinkConstBufferInfo && !xgl_validate_xgl_link_const_buffer((const XGL_LINK_CONST_BUFFER*)pStruct->pLinkConstBufferInfo))
+    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
         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)
+uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* 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))
+    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
         return 0;
-    return 1;
-}
-uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
-{
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+    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_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!validate_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin))
+    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
         return 0;
-    if (!validate_XGL_DEPTH_MODE(pStruct->depthMode))
+    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_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
+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_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
 {
     if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
         return 0;
-    if (!xgl_validate_xgl_rect((const XGL_RECT*)&pStruct->renderArea))
-        return 0;
-    if (pStruct->pColorLoadClearValues && !xgl_validate_xgl_clear_color((const XGL_CLEAR_COLOR*)pStruct->pColorLoadClearValues))
-        return 0;
-    if (!validate_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp))
-        return 0;
-    if (!validate_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp))
-        return 0;
-    if (!validate_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp))
-        return 0;
-    if (!validate_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp))
+    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_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
 {
-    if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
-        return 0;
-    if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+    if (!validate_XGL_FORMAT(pStruct->format))
         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_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
+uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* 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))
+    if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate))
         return 0;
     return 1;
 }
-uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct)
 {
     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 90ba170..5ee31f5 100644 (file)
--- 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,51 +400,45 @@ void dynamic_display_full_txt(const void* pStruct, uint32_t 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')
+// 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_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')
+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_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {}
+xgl_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
+void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_ALLOC_CALLBACKS = %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()
+void xgl_alloc_callbacks_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));
+    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_pipeline_ia_state_create_info_struct_wrapper::display_txt()
+void xgl_alloc_callbacks_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
+void xgl_alloc_callbacks_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_ALLOC_CALLBACKS 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);
-    }
 }
 
 
@@ -497,91 +491,88 @@ void xgl_application_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* 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_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {}
+xgl_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_link_const_buffer_struct_wrapper::display_single_txt()
+void xgl_buffer_copy_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_LINK_CONST_BUFFER = %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_link_const_buffer_struct_wrapper::display_struct_members()
+void xgl_buffer_copy_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));
+    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_link_const_buffer_struct_wrapper::display_txt()
+void xgl_buffer_copy_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_LINK_CONST_BUFFER 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_link_const_buffer_struct_wrapper::display_full_txt()
+void xgl_buffer_copy_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_LINK_CONST_BUFFER 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();
 }
 
 
-// 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')
+// 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_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {}
+xgl_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_update_samplers_struct_wrapper::display_single_txt()
+void xgl_buffer_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_UPDATE_SAMPLERS = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_BUFFER_CREATE_INFO = %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()
+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    %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]);
-    }
+    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_update_samplers_struct_wrapper::display_txt()
+void xgl_buffer_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_update_samplers_struct_wrapper::display_full_txt()
+void xgl_buffer_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -589,144 +580,107 @@ void xgl_update_samplers_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_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_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_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
+xgl_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
+void xgl_buffer_image_copy_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PEER_IMAGE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_BUFFER_IMAGE_COPY = %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_buffer_image_copy_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage));
+    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_peer_image_open_info_struct_wrapper::display_txt()
+void xgl_buffer_image_copy_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_peer_image_open_info_struct_wrapper::display_full_txt()
+void xgl_buffer_image_copy_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
+xgl_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_device_create_info_struct_wrapper::display_single_txt()
+void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DEVICE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %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_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    %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));
+    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_device_create_info_struct_wrapper::display_txt()
+void xgl_buffer_memory_barrier_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_device_create_info_struct_wrapper::display_full_txt()
+void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_BUFFER_MEMORY_BARRIER 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);
     }
@@ -773,409 +727,371 @@ void xgl_buffer_memory_requirements_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {}
+xgl_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_update_buffers_struct_wrapper::display_single_txt()
+void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_UPDATE_BUFFERS = %p", m_indent, "", (void*)m_origStructAddr);
+    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_update_buffers_struct_wrapper::display_struct_members()
+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    %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    %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
 }
 
 // Output all struct elements, each on their own line
-void xgl_update_buffers_struct_wrapper::display_txt()
+void xgl_buffer_view_attach_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_update_buffers_struct_wrapper::display_full_txt()
+void xgl_buffer_view_attach_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_BUFFER_VIEW_ATTACH_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_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')
+// 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_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')
+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_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_struct_wrapper() {}
+xgl_buffer_view_create_info_struct_wrapper::~xgl_buffer_view_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_vertex_input_attribute_description_struct_wrapper::display_single_txt()
+void xgl_buffer_view_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
+    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_vertex_input_attribute_description_struct_wrapper::display_struct_members()
+void xgl_buffer_view_create_info_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %sbinding = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.binding));
+    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    %soffsetInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offsetInBytes));
+    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_vertex_input_attribute_description_struct_wrapper::display_txt()
+void xgl_buffer_view_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_vertex_input_attribute_description_struct_wrapper::display_full_txt()
+void xgl_buffer_view_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_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')
+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_pipeline_vertex_input_create_info_struct_wrapper::~xgl_pipeline_vertex_input_create_info_struct_wrapper() {}
+xgl_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt()
+void xgl_channel_mapping_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_CHANNEL_MAPPING = %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()
+void xgl_channel_mapping_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]);
-    }
+    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_pipeline_vertex_input_create_info_struct_wrapper::display_txt()
+void xgl_channel_mapping_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt()
+void xgl_channel_mapping_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_CHANNEL_MAPPING 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')
+// 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_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')
+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_dynamic_rs_state_create_info_struct_wrapper::~xgl_dynamic_rs_state_create_info_struct_wrapper() {}
+xgl_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_single_txt()
+void xgl_clear_color_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DYNAMIC_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_CLEAR_COLOR = %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()
+void xgl_clear_color_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));
+    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_dynamic_rs_state_create_info_struct_wrapper::display_txt()
+void xgl_clear_color_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_dynamic_rs_state_create_info_struct_wrapper::display_full_txt()
+void xgl_clear_color_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_CLEAR_COLOR 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);
+    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_subresource_layout_struct_wrapper class definition
-xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// 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_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_subresource_layout_struct_wrapper::~xgl_subresource_layout_struct_wrapper() {}
+xgl_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_subresource_layout_struct_wrapper::display_single_txt()
+void xgl_clear_color_value_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_SUBRESOURCE_LAYOUT = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_CLEAR_COLOR_VALUE = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_subresource_layout_struct_wrapper::display_struct_members()
+void xgl_clear_color_value_struct_wrapper::display_struct_members()
 {
-    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));
-    printf("%*s    %srowPitch = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.rowPitch));
-    printf("%*s    %sdepthPitch = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.depthPitch));
+    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_subresource_layout_struct_wrapper::display_txt()
+void xgl_clear_color_value_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_SUBRESOURCE_LAYOUT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_subresource_layout_struct_wrapper::display_full_txt()
+void xgl_clear_color_value_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_SUBRESOURCE_LAYOUT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 
-// 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')
+// 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_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* 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_draw_indexed_indirect_cmd_struct_wrapper::~xgl_draw_indexed_indirect_cmd_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_draw_indexed_indirect_cmd_struct_wrapper::display_single_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DRAW_INDEXED_INDIRECT_CMD = %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_draw_indexed_indirect_cmd_struct_wrapper::display_struct_members()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %sindexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.indexCount));
-    printf("%*s    %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
-    printf("%*s    %sfirstIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstIndex));
-    printf("%*s    %svertexOffset = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexOffset));
-    printf("%*s    %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
+    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_draw_indexed_indirect_cmd_struct_wrapper::display_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD 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_draw_indexed_indirect_cmd_struct_wrapper::display_full_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD 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();
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
 }
 
 
-// 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')
+// 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_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')
+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_dynamic_vp_state_create_info_struct_wrapper::~xgl_dynamic_vp_state_create_info_struct_wrapper() {}
+xgl_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt()
+void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DYNAMIC_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_dynamic_vp_state_create_info_struct_wrapper::display_struct_members()
+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    %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]);
-    }
+    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_dynamic_vp_state_create_info_struct_wrapper::display_txt()
+void xgl_cmd_buffer_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_dynamic_vp_state_create_info_struct_wrapper::display_full_txt()
+void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_CMD_BUFFER_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')
+// 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_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_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_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
+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_shader_create_info_struct_wrapper::display_single_txt()
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_SHADER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_shader_create_info_struct_wrapper::display_struct_members()
+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    %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    %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass));
 }
 
 // Output all struct elements, each on their own line
-void xgl_shader_create_info_struct_wrapper::display_txt()
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_shader_create_info_struct_wrapper::display_full_txt()
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -1183,231 +1099,248 @@ void xgl_shader_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
+xgl_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_memory_ref_struct_wrapper::display_single_txt()
+void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_MEMORY_REF = %p", m_indent, "", (void*)m_origStructAddr);
+    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_memory_ref_struct_wrapper::display_struct_members()
+void xgl_color_attachment_bind_info_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));
+    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_memory_ref_struct_wrapper::display_txt()
+void xgl_color_attachment_bind_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_memory_ref_struct_wrapper::display_full_txt()
+void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 
-// 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_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_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
+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_format_properties_struct_wrapper::display_single_txt()
+void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+    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_format_properties_struct_wrapper::display_struct_members()
+void xgl_color_attachment_view_create_info_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));
+    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_format_properties_struct_wrapper::display_txt()
+void xgl_color_attachment_view_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_format_properties_struct_wrapper::display_full_txt()
+void xgl_color_attachment_view_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* 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_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_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_pipeline_statistics_data_struct_wrapper::display_single_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %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_pipeline_statistics_data_struct_wrapper::display_struct_members()
+void xgl_compute_pipeline_create_info_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));
+    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_pipeline_statistics_data_struct_wrapper::display_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_STATISTICS_DATA 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_pipeline_statistics_data_struct_wrapper::display_full_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_STATISTICS_DATA 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_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_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_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
+xgl_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
+void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_ALLOC_CALLBACKS = %p", m_indent, "", (void*)m_origStructAddr);
+    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_alloc_callbacks_struct_wrapper::display_struct_members()
+void xgl_depth_stencil_bind_info_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    %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_alloc_callbacks_struct_wrapper::display_txt()
+void xgl_depth_stencil_bind_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_alloc_callbacks_struct_wrapper::display_full_txt()
+void xgl_depth_stencil_bind_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DEPTH_STENCIL_BIND_INFO 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')
+// 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_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')
+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_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_info_struct_wrapper() {}
+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_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_cb_state_create_info_struct_wrapper::display_struct_members()
+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    %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]);
-    }
+    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_pipeline_cb_state_create_info_struct_wrapper::display_txt()
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DEPTH_STENCIL_VIEW_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.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);
@@ -1415,534 +1348,522 @@ void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {}
+xgl_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt()
+void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DRAW_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
+    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_draw_indirect_cmd_struct_wrapper::display_struct_members()
+void xgl_descriptor_region_create_info_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));
-}
+    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_draw_indirect_cmd_struct_wrapper::display_txt()
+void xgl_descriptor_region_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_draw_indirect_cmd_struct_wrapper::display_full_txt()
+void xgl_descriptor_region_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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_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_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_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_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_create_info_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_color_attachment_view_create_info_struct_wrapper::display_single_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO = %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_color_attachment_view_create_info_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    %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));
+    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_color_attachment_view_create_info_struct_wrapper::display_txt()
+void xgl_descriptor_set_layout_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_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_color_attachment_view_create_info_struct_wrapper::display_full_txt()
+void xgl_descriptor_set_layout_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_DESCRIPTOR_SET_LAYOUT_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')
+// 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_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')
+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_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_struct_wrapper() {}
+xgl_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
+void xgl_descriptor_type_count_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_CB_ATTACHMENT_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_DESCRIPTOR_TYPE_COUNT = %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()
+void xgl_descriptor_type_count_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));
+    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_pipeline_cb_attachment_state_struct_wrapper::display_txt()
+void xgl_descriptor_type_count_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
+void xgl_descriptor_type_count_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DESCRIPTOR_TYPE_COUNT 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')
+// 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_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')
+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_vertex_input_binding_description_struct_wrapper::~xgl_vertex_input_binding_description_struct_wrapper() {}
+xgl_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_vertex_input_binding_description_struct_wrapper::display_single_txt()
+void xgl_device_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_DEVICE_CREATE_INFO = %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()
+void xgl_device_create_info_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));
+    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_vertex_input_binding_description_struct_wrapper::display_txt()
+void xgl_device_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_vertex_input_binding_description_struct_wrapper::display_full_txt()
+void xgl_device_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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_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_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_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_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {}
+xgl_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
+void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members()
+void xgl_device_queue_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));
+    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_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
+void xgl_device_queue_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
+void xgl_device_queue_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DEVICE_QUEUE_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')
+// 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_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
+xgl_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_fence_create_info_struct_wrapper::display_single_txt()
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %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()
+void xgl_dispatch_indirect_cmd_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    %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_fence_create_info_struct_wrapper::display_txt()
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_fence_create_info_struct_wrapper::display_full_txt()
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DISPATCH_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);
-    }
 }
 
 
-// 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')
+// 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')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_framebuffer_create_info_struct_wrapper::~xgl_framebuffer_create_info_struct_wrapper() {}
+xgl_draw_indexed_indirect_cmd_struct_wrapper::~xgl_draw_indexed_indirect_cmd_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_framebuffer_create_info_struct_wrapper::display_single_txt()
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_FRAMEBUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_DRAW_INDEXED_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_framebuffer_create_info_struct_wrapper::display_struct_members()
+void xgl_draw_indexed_indirect_cmd_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    %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount));
-    uint32_t i;
-    for (i = 0; i<colorAttachmentCount; i++) {
-        printf("%*s    %spColorAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pColorAttachments)[i]);
-    }
-    printf("%*s    %spDepthStencilAttachment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pDepthStencilAttachment));
-    printf("%*s    %ssampleCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleCount));
-    printf("%*s    %swidth = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
-    printf("%*s    %sheight = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
-    printf("%*s    %slayers = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layers));
+    printf("%*s    %sindexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.indexCount));
+    printf("%*s    %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
+    printf("%*s    %sfirstIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstIndex));
+    printf("%*s    %svertexOffset = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexOffset));
+    printf("%*s    %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
 }
 
 // Output all struct elements, each on their own line
-void xgl_framebuffer_create_info_struct_wrapper::display_txt()
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_FRAMEBUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DRAW_INDEXED_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_framebuffer_create_info_struct_wrapper::display_full_txt()
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_FRAMEBUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    if (m_struct.pDepthStencilAttachment) {
-        xgl_depth_stencil_bind_info_struct_wrapper class0(m_struct.pDepthStencilAttachment);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    uint32_t i;
-    for (i = 0; i<colorAttachmentCount; i++) {
-            xgl_color_attachment_bind_info_struct_wrapper class1(&(m_struct.pColorAttachments[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_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_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_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_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_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_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_create_info_struct_wrapper() {}
+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_compute_pipeline_create_info_struct_wrapper::display_single_txt()
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_COMPUTE_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_compute_pipeline_create_info_struct_wrapper::display_struct_members()
+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));
-    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));
+    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_compute_pipeline_create_info_struct_wrapper::display_txt()
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_compute_pipeline_create_info_struct_wrapper::display_full_txt()
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_DYNAMIC_CB_STATE_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')
+// 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_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
+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_image_subresource_range_struct_wrapper::display_single_txt()
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
+    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_image_subresource_range_struct_wrapper::display_struct_members()
+void xgl_dynamic_ds_state_create_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    %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));
+    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_image_subresource_range_struct_wrapper::display_txt()
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_image_subresource_range_struct_wrapper::display_full_txt()
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_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')
+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_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_struct_wrapper() {}
+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_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_tess_state_create_info_struct_wrapper::display_struct_members()
+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    %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));
+    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_pipeline_tess_state_create_info_struct_wrapper::display_txt()
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
+void xgl_dynamic_rs_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);
+    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);
@@ -1950,86 +1871,107 @@ void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* 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_offset2d_struct_wrapper::~xgl_offset2d_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_offset2d_struct_wrapper::display_single_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_OFFSET2D = %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_offset2d_struct_wrapper::display_struct_members()
+void xgl_dynamic_vp_state_create_info_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    %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));
+    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_offset2d_struct_wrapper::display_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_OFFSET2D 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_offset2d_struct_wrapper::display_full_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_OFFSET2D 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_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')
+// 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_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')
+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_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
+xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
+void xgl_event_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_QUEUE_SEMAPHORE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_EVENT_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()
+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    %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()
+void xgl_event_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_queue_semaphore_create_info_struct_wrapper::display_full_txt()
+void xgl_event_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -2037,195 +1979,181 @@ void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {}
+xgl_event_wait_info_struct_wrapper::~xgl_event_wait_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_clear_color_value_struct_wrapper::display_single_txt()
+void xgl_event_wait_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CLEAR_COLOR_VALUE = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_EVENT_WAIT_INFO = %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()
+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<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]);
+    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_clear_color_value_struct_wrapper::display_txt()
+void xgl_event_wait_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_clear_color_value_struct_wrapper::display_full_txt()
+void xgl_event_wait_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* 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_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {}
+xgl_extent2d_struct_wrapper::~xgl_extent2d_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt()
+void xgl_extent2d_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %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_buffer_memory_barrier_struct_wrapper::display_struct_members()
+void xgl_extent2d_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));
+    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_buffer_memory_barrier_struct_wrapper::display_txt()
+void xgl_extent2d_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_BUFFER_MEMORY_BARRIER 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_buffer_memory_barrier_struct_wrapper::display_full_txt()
+void xgl_extent2d_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_BUFFER_MEMORY_BARRIER 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();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
 }
 
 
-// xgl_pipeline_ms_state_create_info_struct_wrapper class definition
-xgl_pipeline_ms_state_create_info_struct_wrapper::xgl_pipeline_ms_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_ms_state_create_info_struct_wrapper::xgl_pipeline_ms_state_create_info_struct_wrapper(XGL_PIPELINE_MS_STATE_CREATE_INFO* 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_pipeline_ms_state_create_info_struct_wrapper::xgl_pipeline_ms_state_create_info_struct_wrapper(const XGL_PIPELINE_MS_STATE_CREATE_INFO* 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_pipeline_ms_state_create_info_struct_wrapper::~xgl_pipeline_ms_state_create_info_struct_wrapper() {}
+xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_ms_state_create_info_struct_wrapper::display_single_txt()
+void xgl_extent3d_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_MS_STATE_CREATE_INFO = %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_pipeline_ms_state_create_info_struct_wrapper::display_struct_members()
+void xgl_extent3d_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    %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
-    printf("%*s    %smultisampleEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.multisampleEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %ssampleShadingEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleShadingEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %sminSampleShading = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minSampleShading));
-    printf("%*s    %ssampleMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleMask));
+    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_pipeline_ms_state_create_info_struct_wrapper::display_txt()
+void xgl_extent3d_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_MS_STATE_CREATE_INFO 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_pipeline_ms_state_create_info_struct_wrapper::display_full_txt()
+void xgl_extent3d_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_MS_STATE_CREATE_INFO 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();
-    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')
+// 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_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_pipeline_rs_state_create_info_struct_wrapper::~xgl_pipeline_rs_state_create_info_struct_wrapper() {}
+xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_rs_state_create_info_struct_wrapper::display_single_txt()
+void xgl_fence_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_rs_state_create_info_struct_wrapper::display_struct_members()
+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    %sdepthClipEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthClipEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %srasterizerDiscardEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.rasterizerDiscardEnable) ? "TRUE" : "FALSE");
-    printf("%*s    %sprogramPointSize = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.programPointSize) ? "TRUE" : "FALSE");
-    printf("%*s    %spointOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.pointOrigin));
-    printf("%*s    %sprovokingVertex = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(m_struct.provokingVertex));
-    printf("%*s    %sfillMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FILL_MODE(m_struct.fillMode));
-    printf("%*s    %scullMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CULL_MODE(m_struct.cullMode));
-    printf("%*s    %sfrontFace = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FACE_ORIENTATION(m_struct.frontFace));
+    printf("%*s    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
 }
 
 // Output all struct elements, each on their own line
-void xgl_pipeline_rs_state_create_info_struct_wrapper::display_txt()
+void xgl_fence_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_rs_state_create_info_struct_wrapper::display_full_txt()
+void xgl_fence_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -2233,114 +2161,105 @@ void xgl_pipeline_rs_state_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {}
+xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_create_info_struct_wrapper::display_single_txt()
+void xgl_format_properties_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_FORMAT_PROPERTIES = %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()
+void xgl_format_properties_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));
+    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_image_create_info_struct_wrapper::display_txt()
+void xgl_format_properties_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_image_create_info_struct_wrapper::display_full_txt()
+void xgl_format_properties_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_FORMAT_PROPERTIES 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_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')
+// 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')
 {
     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')
+xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {}
+xgl_framebuffer_create_info_struct_wrapper::~xgl_framebuffer_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_update_images_struct_wrapper::display_single_txt()
+void xgl_framebuffer_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_UPDATE_IMAGES = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_FRAMEBUFFER_CREATE_INFO = %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()
+void xgl_framebuffer_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));
+    printf("%*s    %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount));
     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]);
+    for (i = 0; i<colorAttachmentCount; i++) {
+        printf("%*s    %spColorAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pColorAttachments)[i]);
     }
+    printf("%*s    %spDepthStencilAttachment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pDepthStencilAttachment));
+    printf("%*s    %ssampleCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleCount));
+    printf("%*s    %swidth = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+    printf("%*s    %sheight = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+    printf("%*s    %slayers = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layers));
 }
 
 // Output all struct elements, each on their own line
-void xgl_update_images_struct_wrapper::display_txt()
+void xgl_framebuffer_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_FRAMEBUFFER_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_images_struct_wrapper::display_full_txt()
+void xgl_framebuffer_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_FRAMEBUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
+    if (m_struct.pDepthStencilAttachment) {
+        xgl_depth_stencil_bind_info_struct_wrapper class0(m_struct.pDepthStencilAttachment);
+        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();
+    for (i = 0; i<colorAttachmentCount; i++) {
+            xgl_color_attachment_bind_info_struct_wrapper class1(&(m_struct.pColorAttachments[i]));
+            class1.set_indent(m_indent + 4);
+            class1.display_full_txt();
     }
     if (m_struct.pNext) {
         dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -2348,108 +2267,43 @@ void xgl_update_images_struct_wrapper::display_full_txt()
 }
 
 
-// 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_gpu_compatibility_info_struct_wrapper class definition
+xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_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_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_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_gpu_compatibility_info_struct_wrapper::~xgl_gpu_compatibility_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_single_txt()
+void xgl_gpu_compatibility_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CMD_BUFFER_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_GPU_COMPATIBILITY_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_gpu_compatibility_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    %scompatibilityFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.compatibilityFlags));
 }
 
 // Output all struct elements, each on their own line
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_txt()
+void xgl_gpu_compatibility_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_GPU_COMPATIBILITY_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_gpu_compatibility_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_GPU_COMPATIBILITY_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_image_view_create_info_struct_wrapper class definition
-xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
-    m_struct = *pInStruct;
-    m_origStructAddr = pInStruct;
-}
-xgl_image_view_create_info_struct_wrapper::~xgl_image_view_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_view_create_info_struct_wrapper::display_single_txt()
-{
-    printf(" %*sXGL_IMAGE_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_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    %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_VIEW_TYPE(m_struct.viewType));
-    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    %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
-    printf("%*s    %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_view_create_info_struct_wrapper::display_txt()
-{
-    printf("%*sXGL_IMAGE_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_image_view_create_info_struct_wrapper::display_full_txt()
-{
-    printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
-    this->display_struct_members();
-    if (&m_struct.subresourceRange) {
-        xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
-        class0.set_indent(m_indent + 4);
-        class0.display_full_txt();
-    }
-    if (&m_struct.channels) {
-        xgl_channel_mapping_struct_wrapper class1(&m_struct.channels);
-        class1.set_indent(m_indent + 4);
-        class1.display_full_txt();
-    }
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
 }
 
 
@@ -2499,257 +2353,308 @@ void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// xgl_image_copy_struct_wrapper class definition
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* 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')
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
+xgl_image_copy_struct_wrapper::~xgl_image_copy_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_rect_struct_wrapper::display_single_txt()
+void xgl_image_copy_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_IMAGE_COPY = %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()
+void xgl_image_copy_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
+    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_rect_struct_wrapper::display_txt()
+void xgl_image_copy_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_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_rect_struct_wrapper::display_full_txt()
+void xgl_image_copy_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_COPY 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);
+        xgl_extent3d_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);
+    if (&m_struct.destOffset) {
+        xgl_offset3d_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_offset3d_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_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')
+// 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_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')
+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_cmd_buffer_graphics_begin_info_struct_wrapper::~xgl_cmd_buffer_graphics_begin_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_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt()
+void xgl_image_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_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_cmd_buffer_graphics_begin_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    %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass));
+    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_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt()
+void xgl_image_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_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_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt()
+void xgl_image_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_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.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_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')
+// xgl_image_memory_barrier_struct_wrapper class definition
+xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper(XGL_IMAGE_MEMORY_BARRIER* 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')
+xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper(const XGL_IMAGE_MEMORY_BARRIER* 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() {}
+xgl_image_memory_barrier_struct_wrapper::~xgl_image_memory_barrier_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
+void xgl_image_memory_barrier_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DEVICE_QUEUE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_IMAGE_MEMORY_BARRIER = %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()
+void xgl_image_memory_barrier_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));
+    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    %soldLayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.oldLayout));
+    printf("%*s    %snewLayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.newLayout));
+    printf("%*s    %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+    printf("%*s    %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
 }
 
 // Output all struct elements, each on their own line
-void xgl_device_queue_create_info_struct_wrapper::display_txt()
+void xgl_image_memory_barrier_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_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_device_queue_create_info_struct_wrapper::display_full_txt()
+void xgl_image_memory_barrier_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
+    if (&m_struct.subresourceRange) {
+        xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
+        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_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')
+// 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_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
+xgl_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_memory_open_info_struct_wrapper::display_single_txt()
+void xgl_image_memory_bind_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_memory_open_info_struct_wrapper::display_struct_members()
+void xgl_image_memory_bind_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));
+    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_memory_open_info_struct_wrapper::display_txt()
+void xgl_image_memory_bind_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_memory_open_info_struct_wrapper::display_full_txt()
+void xgl_image_memory_bind_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_MEMORY_BIND_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);
+    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.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_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_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_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_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_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {}
+xgl_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_update_as_copy_struct_wrapper::display_single_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_UPDATE_AS_COPY = %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_update_as_copy_struct_wrapper::display_struct_members()
+void xgl_image_memory_requirements_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    %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_update_as_copy_struct_wrapper::display_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_UPDATE_AS_COPY 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_update_as_copy_struct_wrapper::display_full_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_UPDATE_AS_COPY 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();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
-    }
 }
 
 
-// xgl_image_copy_struct_wrapper class definition
-xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* 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_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* 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_image_copy_struct_wrapper::~xgl_image_copy_struct_wrapper() {}
+xgl_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_copy_struct_wrapper::display_single_txt()
+void xgl_image_resolve_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_COPY = %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_image_copy_struct_wrapper::display_struct_members()
+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));
@@ -2759,24 +2664,24 @@ void xgl_image_copy_struct_wrapper::display_struct_members()
 }
 
 // Output all struct elements, each on their own line
-void xgl_image_copy_struct_wrapper::display_txt()
+void xgl_image_resolve_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_COPY 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_image_copy_struct_wrapper::display_full_txt()
+void xgl_image_resolve_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_COPY 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_extent3d_struct_wrapper class0(&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_offset3d_struct_wrapper class1(&m_struct.destOffset);
+        xgl_offset2d_struct_wrapper class1(&m_struct.destOffset);
         class1.set_indent(m_indent + 4);
         class1.display_full_txt();
     }
@@ -2786,7 +2691,7 @@ void xgl_image_copy_struct_wrapper::display_full_txt()
         class2.display_full_txt();
     }
     if (&m_struct.srcOffset) {
-        xgl_offset3d_struct_wrapper class3(&m_struct.srcOffset);
+        xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset);
         class3.set_indent(m_indent + 4);
         class3.display_full_txt();
     }
@@ -2798,159 +2703,131 @@ void xgl_image_copy_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
+xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_resolve_struct_wrapper::display_single_txt()
+void xgl_image_subresource_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_RESOLVE = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_IMAGE_SUBRESOURCE = %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()
+void xgl_image_subresource_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));
+    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_resolve_struct_wrapper::display_txt()
+void xgl_image_subresource_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_resolve_struct_wrapper::display_full_txt()
+void xgl_image_subresource_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_SUBRESOURCE 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')
+// 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_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')
+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_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
+xgl_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
+void xgl_image_subresource_range_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_COLOR_ATTACHMENT_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %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()
+void xgl_image_subresource_range_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));
+    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_color_attachment_bind_info_struct_wrapper::display_txt()
+void xgl_image_subresource_range_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_color_attachment_bind_info_struct_wrapper::display_full_txt()
+void xgl_image_subresource_range_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE 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')
+// 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_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')
+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_dynamic_ds_state_create_info_struct_wrapper::~xgl_dynamic_ds_state_create_info_struct_wrapper() {}
+xgl_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_single_txt()
+void xgl_image_view_attach_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DYNAMIC_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_dynamic_ds_state_create_info_struct_wrapper::display_struct_members()
+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    %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));
+    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_dynamic_ds_state_create_info_struct_wrapper::display_txt()
+void xgl_image_view_attach_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_dynamic_ds_state_create_info_struct_wrapper::display_full_txt()
+void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -2958,170 +2835,242 @@ void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// xgl_image_memory_barrier_struct_wrapper class definition
-xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper(XGL_IMAGE_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_view_create_info_struct_wrapper class definition
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper(const XGL_IMAGE_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_image_memory_barrier_struct_wrapper::~xgl_image_memory_barrier_struct_wrapper() {}
+xgl_image_view_create_info_struct_wrapper::~xgl_image_view_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_memory_barrier_struct_wrapper::display_single_txt()
+void xgl_image_view_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_IMAGE_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_image_memory_barrier_struct_wrapper::display_struct_members()
+void xgl_image_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    %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    %soldLayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.oldLayout));
-    printf("%*s    %snewLayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.newLayout));
     printf("%*s    %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+    printf("%*s    %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_VIEW_TYPE(m_struct.viewType));
+    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    %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
+    printf("%*s    %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_view_create_info_struct_wrapper::display_txt()
+{
+    printf("%*sXGL_IMAGE_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_image_view_create_info_struct_wrapper::display_full_txt()
+{
+    printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    this->display_struct_members();
+    if (&m_struct.subresourceRange) {
+        xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
+        class0.set_indent(m_indent + 4);
+        class0.display_full_txt();
+    }
+    if (&m_struct.channels) {
+        xgl_channel_mapping_struct_wrapper class1(&m_struct.channels);
+        class1.set_indent(m_indent + 4);
+        class1.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
+}
+
+
+// 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_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_image_memory_barrier_struct_wrapper::display_txt()
+void xgl_link_const_buffer_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_image_memory_barrier_struct_wrapper::display_full_txt()
+void xgl_link_const_buffer_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    if (&m_struct.subresourceRange) {
-        xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
-        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_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')
+// 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')
 {
     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')
+xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_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() {}
+xgl_memory_alloc_buffer_info_struct_wrapper::~xgl_memory_alloc_buffer_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt()
+void xgl_memory_alloc_buffer_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_MEMORY_ALLOC_BUFFER_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()
+void xgl_memory_alloc_buffer_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));
+    printf("%*s    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
 }
 
 // Output all struct elements, each on their own line
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt()
+void xgl_memory_alloc_buffer_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_MEMORY_ALLOC_BUFFER_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()
+void xgl_memory_alloc_buffer_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_MEMORY_ALLOC_BUFFER_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')
+// 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_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {}
+xgl_memory_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_barrier_struct_wrapper::display_single_txt()
+void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_barrier_struct_wrapper::display_struct_members()
+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    %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]);
-    }
+    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_pipeline_barrier_struct_wrapper::display_txt()
+void xgl_memory_alloc_image_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_barrier_struct_wrapper::display_full_txt()
+void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -3129,87 +3078,93 @@ void xgl_pipeline_barrier_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* 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_physical_gpu_memory_properties_struct_wrapper::~xgl_physical_gpu_memory_properties_struct_wrapper() {}
+xgl_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_memory_properties_struct_wrapper::display_single_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PHYSICAL_GPU_MEMORY_PROPERTIES = %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_physical_gpu_memory_properties_struct_wrapper::display_struct_members()
+void xgl_memory_alloc_info_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %ssupportsMigration = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsMigration) ? "TRUE" : "FALSE");
-    printf("%*s    %ssupportsPinning = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsPinning) ? "TRUE" : "FALSE");
+    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_physical_gpu_memory_properties_struct_wrapper::display_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_MEMORY_PROPERTIES 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_physical_gpu_memory_properties_struct_wrapper::display_full_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_MEMORY_PROPERTIES 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);
+    }
 }
 
 
-// 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')
+// 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_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')
+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_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {}
+xgl_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt()
+void xgl_memory_barrier_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_MEMORY_ALLOC_IMAGE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_MEMORY_BARRIER = %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()
+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    %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));
+    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_alloc_image_info_struct_wrapper::display_txt()
+void xgl_memory_barrier_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_alloc_image_info_struct_wrapper::display_full_txt()
+void xgl_memory_barrier_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -3217,561 +3172,536 @@ void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_struct_wrapper() {}
+xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_update_sampler_textures_struct_wrapper::display_single_txt()
+void xgl_memory_open_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_MEMORY_OPEN_INFO = %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()
+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    %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]);
-    }
+    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_update_sampler_textures_struct_wrapper::display_txt()
+void xgl_memory_open_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_update_sampler_textures_struct_wrapper::display_full_txt()
+void xgl_memory_open_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_MEMORY_OPEN_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_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')
+// 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_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')
+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_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
+xgl_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
+void xgl_memory_ref_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %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_peer_memory_open_info_struct_wrapper::display_struct_members()
+void xgl_memory_ref_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    %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_peer_memory_open_info_struct_wrapper::display_txt()
+void xgl_memory_ref_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PEER_MEMORY_OPEN_INFO 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_peer_memory_open_info_struct_wrapper::display_full_txt()
+void xgl_memory_ref_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PEER_MEMORY_OPEN_INFO 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.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')
+// 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_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {}
+xgl_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_descriptor_type_count_struct_wrapper::display_single_txt()
+void xgl_memory_requirements_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DESCRIPTOR_TYPE_COUNT = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_MEMORY_REQUIREMENTS = %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()
+void xgl_memory_requirements_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));
+    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_descriptor_type_count_struct_wrapper::display_txt()
+void xgl_memory_requirements_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_descriptor_type_count_struct_wrapper::display_full_txt()
+void xgl_memory_requirements_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_MEMORY_REQUIREMENTS 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')
+// 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_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* 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_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
+xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
+void xgl_offset2d_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %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_dispatch_indirect_cmd_struct_wrapper::display_struct_members()
+void xgl_offset2d_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));
+    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_dispatch_indirect_cmd_struct_wrapper::display_txt()
+void xgl_offset2d_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DISPATCH_INDIRECT_CMD 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_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
+void xgl_offset2d_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DISPATCH_INDIRECT_CMD 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();
 }
 
 
-// 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')
+// 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_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')
+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_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_info_struct_wrapper() {}
+xgl_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt()
+void xgl_offset3d_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DESCRIPTOR_REGION_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_OFFSET3D = %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()
+void xgl_offset3d_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]);
-    }
+    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_descriptor_region_create_info_struct_wrapper::display_txt()
+void xgl_offset3d_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_descriptor_region_create_info_struct_wrapper::display_full_txt()
+void xgl_offset3d_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_OFFSET3D 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')
+// 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_viewport_struct_wrapper::xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_viewport_struct_wrapper::~xgl_viewport_struct_wrapper() {}
+xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_viewport_struct_wrapper::display_single_txt()
+void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_VIEWPORT = %p", m_indent, "", (void*)m_origStructAddr);
+    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_viewport_struct_wrapper::display_struct_members()
+void xgl_peer_image_open_info_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));
+    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_viewport_struct_wrapper::display_txt()
+void xgl_peer_image_open_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_viewport_struct_wrapper::display_full_txt()
+void xgl_peer_image_open_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PEER_IMAGE_OPEN_INFO 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')
+// 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_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')
+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_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_create_info_struct_wrapper() {}
+xgl_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
+void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_depth_stencil_view_create_info_struct_wrapper::display_struct_members()
+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    %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));
+    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_depth_stencil_view_create_info_struct_wrapper::display_txt()
+void xgl_peer_memory_open_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
+void xgl_peer_memory_open_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PEER_MEMORY_OPEN_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')
+// 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')
 {
     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')
+xgl_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* 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() {}
+xgl_physical_gpu_memory_properties_struct_wrapper::~xgl_physical_gpu_memory_properties_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_memory_properties_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_QUERY_POOL_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PHYSICAL_GPU_MEMORY_PROPERTIES = %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()
+void xgl_physical_gpu_memory_properties_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));
+    printf("%*s    %ssupportsMigration = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsMigration) ? "TRUE" : "FALSE");
+    printf("%*s    %ssupportsPinning = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsPinning) ? "TRUE" : "FALSE");
 }
 
 // Output all struct elements, each on their own line
-void xgl_query_pool_create_info_struct_wrapper::display_txt()
+void xgl_physical_gpu_memory_properties_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PHYSICAL_GPU_MEMORY_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_query_pool_create_info_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_memory_properties_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PHYSICAL_GPU_MEMORY_PROPERTIES 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')
+// 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_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')
+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_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
+xgl_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_performance_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %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()
+void xgl_physical_gpu_performance_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));
+    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_cmd_buffer_create_info_struct_wrapper::display_txt()
+void xgl_physical_gpu_performance_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_cmd_buffer_create_info_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_performance_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE 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')
+// 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_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')
+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_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
+xgl_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_properties_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DEPTH_STENCIL_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %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()
+void xgl_physical_gpu_properties_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));
+    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_depth_stencil_bind_info_struct_wrapper::display_txt()
+void xgl_physical_gpu_properties_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_depth_stencil_bind_info_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_properties_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PHYSICAL_GPU_PROPERTIES 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_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_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* 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_memory_requirements_struct_wrapper::~xgl_memory_requirements_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_memory_requirements_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_MEMORY_REQUIREMENTS = %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_memory_requirements_struct_wrapper::display_struct_members()
+void xgl_physical_gpu_queue_properties_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));
+    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_memory_requirements_struct_wrapper::display_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_MEMORY_REQUIREMENTS 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_memory_requirements_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_MEMORY_REQUIREMENTS 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_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')
+// 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_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')
+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_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
+xgl_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_barrier_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PIPELINE_BARRIER = %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()
+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    %ssharedSemaphore = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedSemaphore));
+    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_queue_semaphore_open_info_struct_wrapper::display_txt()
+void xgl_pipeline_barrier_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_queue_semaphore_open_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_barrier_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -3779,226 +3709,264 @@ void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {}
+xgl_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_memory_barrier_struct_wrapper::display_single_txt()
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+    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_memory_barrier_struct_wrapper::display_struct_members()
+void xgl_pipeline_cb_attachment_state_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    %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_memory_barrier_struct_wrapper::display_txt()
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_memory_barrier_struct_wrapper::display_full_txt()
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE 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_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_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_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_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
+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_physical_gpu_performance_struct_wrapper::display_single_txt()
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %p", m_indent, "", (void*)m_origStructAddr);
+    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_physical_gpu_performance_struct_wrapper::display_struct_members()
+void xgl_pipeline_cb_state_create_info_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    %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_physical_gpu_performance_struct_wrapper::display_txt()
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_physical_gpu_performance_struct_wrapper::display_full_txt()
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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_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_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {}
+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_channel_mapping_struct_wrapper::display_single_txt()
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CHANNEL_MAPPING = %p", m_indent, "", (void*)m_origStructAddr);
+    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_channel_mapping_struct_wrapper::display_struct_members()
+void xgl_pipeline_ds_state_create_info_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    %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_channel_mapping_struct_wrapper::display_txt()
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_channel_mapping_struct_wrapper::display_full_txt()
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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_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_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* 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_clear_color_struct_wrapper::~xgl_clear_color_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_clear_color_struct_wrapper::display_single_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_CLEAR_COLOR = %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_clear_color_struct_wrapper::display_struct_members()
+void xgl_pipeline_ia_state_create_info_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    %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_clear_color_struct_wrapper::display_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_CLEAR_COLOR 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_clear_color_struct_wrapper::display_full_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_CLEAR_COLOR 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.color) {
-        xgl_clear_color_value_struct_wrapper class0(&m_struct.color);
-        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')
+// xgl_pipeline_ms_state_create_info_struct_wrapper class definition
+xgl_pipeline_ms_state_create_info_struct_wrapper::xgl_pipeline_ms_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_ms_state_create_info_struct_wrapper::xgl_pipeline_ms_state_create_info_struct_wrapper(XGL_PIPELINE_MS_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')
+xgl_pipeline_ms_state_create_info_struct_wrapper::xgl_pipeline_ms_state_create_info_struct_wrapper(const XGL_PIPELINE_MS_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() {}
+xgl_pipeline_ms_state_create_info_struct_wrapper::~xgl_pipeline_ms_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()
+void xgl_pipeline_ms_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DYNAMIC_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PIPELINE_MS_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()
+void xgl_pipeline_ms_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]);
-    }
+    printf("%*s    %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+    printf("%*s    %smultisampleEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.multisampleEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %ssampleShadingEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleShadingEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %sminSampleShading = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minSampleShading));
+    printf("%*s    %ssampleMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleMask));
 }
 
 // Output all struct elements, each on their own line
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_ms_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_MS_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()
+void xgl_pipeline_ms_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);
+    printf("%*sXGL_PIPELINE_MS_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);
@@ -4006,268 +3974,250 @@ void xgl_dynamic_cb_state_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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')
 {
     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')
+xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_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() {}
+xgl_pipeline_rs_state_create_info_struct_wrapper::~xgl_pipeline_rs_state_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_buffer_view_create_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_BUFFER_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PIPELINE_RS_STATE_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()
+void xgl_pipeline_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    %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));
+    printf("%*s    %sdepthClipEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthClipEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %srasterizerDiscardEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.rasterizerDiscardEnable) ? "TRUE" : "FALSE");
+    printf("%*s    %sprogramPointSize = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.programPointSize) ? "TRUE" : "FALSE");
+    printf("%*s    %spointOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.pointOrigin));
+    printf("%*s    %sprovokingVertex = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(m_struct.provokingVertex));
+    printf("%*s    %sfillMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FILL_MODE(m_struct.fillMode));
+    printf("%*s    %scullMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CULL_MODE(m_struct.cullMode));
+    printf("%*s    %sfrontFace = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FACE_ORIENTATION(m_struct.frontFace));
 }
 
 // Output all struct elements, each on their own line
-void xgl_buffer_view_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_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_buffer_view_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_RS_STATE_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')
+// 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_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_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_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
+xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_sampler_create_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_shader_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_SAMPLER_CREATE_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_sampler_create_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_shader_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));
+    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_sampler_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_shader_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_SAMPLER_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_sampler_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_shader_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_SAMPLER_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();
-    if (m_struct.pNext) {
-        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    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_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')
+// 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_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_event_wait_info_struct_wrapper::~xgl_event_wait_info_struct_wrapper() {}
+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_event_wait_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_EVENT_WAIT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_event_wait_info_struct_wrapper::display_struct_members()
+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    %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]);
-    }
+    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_event_wait_info_struct_wrapper::display_txt()
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_event_wait_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {}
+xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_buffer_image_copy_struct_wrapper::display_single_txt()
+void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_BUFFER_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %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()
+void xgl_pipeline_statistics_data_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));
+    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_buffer_image_copy_struct_wrapper::display_txt()
+void xgl_pipeline_statistics_data_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_buffer_image_copy_struct_wrapper::display_full_txt()
+void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_PIPELINE_STATISTICS_DATA 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')
+// 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_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
+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_event_create_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_EVENT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_event_create_info_struct_wrapper::display_struct_members()
+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    %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+    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_event_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_event_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -4275,102 +4225,110 @@ void xgl_event_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
+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_physical_gpu_properties_struct_wrapper::display_single_txt()
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+    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_physical_gpu_properties_struct_wrapper::display_struct_members()
+void xgl_pipeline_vertex_input_create_info_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));
+    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<XGL_MAX_PHYSICAL_GPU_NAME; i++) {
-        printf("%*s    %sgpuName = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuName));
+    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]);
     }
-    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()
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_physical_gpu_properties_struct_wrapper::display_full_txt()
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_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')
+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_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
+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_image_view_attach_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_image_view_attach_info_struct_wrapper::display_struct_members()
+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    %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));
+    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_image_view_attach_info_struct_wrapper::display_txt()
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_image_view_attach_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -4378,44 +4336,45 @@ void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_memory_alloc_buffer_info_struct_wrapper::~xgl_memory_alloc_buffer_info_struct_wrapper() {}
+xgl_query_pool_create_info_struct_wrapper::~xgl_query_pool_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_buffer_info_struct_wrapper::display_single_txt()
+void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_MEMORY_ALLOC_BUFFER_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_memory_alloc_buffer_info_struct_wrapper::display_struct_members()
+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    %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+    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_memory_alloc_buffer_info_struct_wrapper::display_txt()
+void xgl_query_pool_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_MEMORY_ALLOC_BUFFER_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_memory_alloc_buffer_info_struct_wrapper::display_full_txt()
+void xgl_query_pool_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_MEMORY_ALLOC_BUFFER_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -4423,458 +4382,498 @@ void xgl_memory_alloc_buffer_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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')
+// 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_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {}
+xgl_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_buffer_copy_struct_wrapper::display_single_txt()
+void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_BUFFER_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+    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_buffer_copy_struct_wrapper::display_struct_members()
+void xgl_queue_semaphore_create_info_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));
+    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_buffer_copy_struct_wrapper::display_txt()
+void xgl_queue_semaphore_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_buffer_copy_struct_wrapper::display_full_txt()
+void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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_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_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_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_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_info_struct_wrapper() {}
+xgl_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_memory_bind_info_struct_wrapper::display_single_txt()
+void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_MEMORY_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_image_memory_bind_info_struct_wrapper::display_struct_members()
+void xgl_queue_semaphore_open_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));
+    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_image_memory_bind_info_struct_wrapper::display_txt()
+void xgl_queue_semaphore_open_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_image_memory_bind_info_struct_wrapper::display_full_txt()
+void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_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.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_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')
+// 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_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {}
+xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_memory_requirements_struct_wrapper::display_single_txt()
+void xgl_rect_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_RECT = %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()
+void xgl_rect_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));
+    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_requirements_struct_wrapper::display_txt()
+void xgl_rect_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_image_memory_requirements_struct_wrapper::display_full_txt()
+void xgl_rect_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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')
 {
     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')
+xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper(const XGL_RENDER_PASS_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
 {
     m_struct = *pInStruct;
     m_origStructAddr = pInStruct;
 }
-xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
+xgl_render_pass_create_info_struct_wrapper::~xgl_render_pass_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_shader_struct_wrapper::display_single_txt()
+void xgl_render_pass_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_SHADER = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_RENDER_PASS_CREATE_INFO = %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()
+void xgl_render_pass_create_info_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));
+    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    %srenderArea = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.renderArea));
+    printf("%*s    %sframebuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.framebuffer));
+    printf("%*s    %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount));
     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]);
+    for (i = 0; i<colorAttachmentCount; i++) {
+        printf("%*s    %spColorLoadOps[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_ATTACHMENT_LOAD_OP(*m_struct.pColorLoadOps)[i]);
+    }
+    for (i = 0; i<colorAttachmentCount; i++) {
+        printf("%*s    %spColorStoreOps[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_ATTACHMENT_STORE_OP(*m_struct.pColorStoreOps)[i]);
+    }
+    for (i = 0; i<colorAttachmentCount; i++) {
+        printf("%*s    %spColorLoadClearValues[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pColorLoadClearValues)[i]);
     }
+    printf("%*s    %sdepthLoadOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_LOAD_OP(m_struct.depthLoadOp));
+    printf("%*s    %sdepthLoadClearValue = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthLoadClearValue));
+    printf("%*s    %sdepthStoreOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_STORE_OP(m_struct.depthStoreOp));
+    printf("%*s    %sstencilLoadOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_LOAD_OP(m_struct.stencilLoadOp));
+    printf("%*s    %sstencilLoadClearValue = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilLoadClearValue));
+    printf("%*s    %sstencilStoreOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_STORE_OP(m_struct.stencilStoreOp));
 }
 
 // Output all struct elements, each on their own line
-void xgl_pipeline_shader_struct_wrapper::display_txt()
+void xgl_render_pass_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_RENDER_PASS_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_struct_wrapper::display_full_txt()
+void xgl_render_pass_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_RENDER_PASS_CREATE_INFO 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]));
+    for (i = 0; i<colorAttachmentCount; i++) {
+            xgl_clear_color_struct_wrapper class0(&(m_struct.pColorLoadClearValues[i]));
             class0.set_indent(m_indent + 4);
             class0.display_full_txt();
     }
+    if (&m_struct.renderArea) {
+        xgl_rect_struct_wrapper class1(&m_struct.renderArea);
+        class1.set_indent(m_indent + 4);
+        class1.display_full_txt();
+    }
+    if (m_struct.pNext) {
+        dynamic_display_full_txt(m_struct.pNext, m_indent);
+    }
 }
 
 
-// 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_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_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
+xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_offset3d_struct_wrapper::display_single_txt()
+void xgl_sampler_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_OFFSET3D = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_SAMPLER_CREATE_INFO = %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_sampler_create_info_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));
+    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_offset3d_struct_wrapper::display_txt()
+void xgl_sampler_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_offset3d_struct_wrapper::display_full_txt()
+void xgl_sampler_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_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')
+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_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_struct_wrapper() {}
+xgl_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt()
+void xgl_sampler_image_view_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_BUFFER_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_buffer_view_attach_info_struct_wrapper::display_struct_members()
+void xgl_sampler_image_view_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    %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_buffer_view_attach_info_struct_wrapper::display_txt()
+void xgl_sampler_image_view_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_buffer_view_attach_info_struct_wrapper::display_full_txt()
+void xgl_sampler_image_view_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_SAMPLER_IMAGE_VIEW_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);
+    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_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')
+// 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_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
+xgl_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_extent3d_struct_wrapper::display_single_txt()
+void xgl_shader_create_info_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_EXTENT3D = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_SHADER_CREATE_INFO = %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()
+void xgl_shader_create_info_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));
+    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_extent3d_struct_wrapper::display_txt()
+void xgl_shader_create_info_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_extent3d_struct_wrapper::display_full_txt()
+void xgl_shader_create_info_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
+    }
 }
 
 
-// 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')
+// 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_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')
+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_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {}
+xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_sampler_image_view_info_struct_wrapper::display_single_txt()
+void xgl_stencil_op_state_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_SAMPLER_IMAGE_VIEW_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_STENCIL_OP_STATE = %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()
+void xgl_stencil_op_state_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));
+    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_sampler_image_view_info_struct_wrapper::display_txt()
+void xgl_stencil_op_state_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_sampler_image_view_info_struct_wrapper::display_full_txt()
+void xgl_stencil_op_state_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_STENCIL_OP_STATE 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')
+// xgl_subresource_layout_struct_wrapper class definition
+xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* 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_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* 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_subresource_layout_struct_wrapper::~xgl_subresource_layout_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_image_subresource_struct_wrapper::display_single_txt()
+void xgl_subresource_layout_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_IMAGE_SUBRESOURCE = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_SUBRESOURCE_LAYOUT = %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_subresource_layout_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    %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));
+    printf("%*s    %srowPitch = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.rowPitch));
+    printf("%*s    %sdepthPitch = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.depthPitch));
 }
 
 // Output all struct elements, each on their own line
-void xgl_image_subresource_struct_wrapper::display_txt()
+void xgl_subresource_layout_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_SUBRESOURCE_LAYOUT 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_subresource_layout_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_SUBRESOURCE_LAYOUT 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')
+// 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_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_layer_create_info_struct_wrapper::~xgl_layer_create_info_struct_wrapper() {}
+xgl_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_layer_create_info_struct_wrapper::display_single_txt()
+void xgl_update_as_copy_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_LAYER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_UPDATE_AS_COPY = %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()
+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    %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]);
-    }
+    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_layer_create_info_struct_wrapper::display_txt()
+void xgl_update_as_copy_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_layer_create_info_struct_wrapper::display_full_txt()
+void xgl_update_as_copy_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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);
@@ -4882,349 +4881,350 @@ void xgl_layer_create_info_struct_wrapper::display_full_txt()
 }
 
 
-// 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_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_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_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_pipeline_vp_state_create_info_struct_wrapper::~xgl_pipeline_vp_state_create_info_struct_wrapper() {}
+xgl_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_single_txt()
+void xgl_update_buffers_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PIPELINE_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_UPDATE_BUFFERS = %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_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    %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    %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_pipeline_vp_state_create_info_struct_wrapper::display_txt()
+void xgl_update_buffers_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_pipeline_vp_state_create_info_struct_wrapper::display_full_txt()
+void xgl_update_buffers_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_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')
+// 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_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_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_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {}
+xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_buffer_create_info_struct_wrapper::display_single_txt()
+void xgl_update_images_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_BUFFER_CREATE_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_buffer_create_info_struct_wrapper::display_struct_members()
+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    %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));
+    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_buffer_create_info_struct_wrapper::display_txt()
+void xgl_update_images_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_BUFFER_CREATE_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_buffer_create_info_struct_wrapper::display_full_txt()
+void xgl_update_images_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_BUFFER_CREATE_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();
+    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_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')
+// 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_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper(const XGL_RENDER_PASS_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_render_pass_create_info_struct_wrapper::~xgl_render_pass_create_info_struct_wrapper() {}
+xgl_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_render_pass_create_info_struct_wrapper::display_single_txt()
+void xgl_update_samplers_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_RENDER_PASS_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_UPDATE_SAMPLERS = %p", m_indent, "", (void*)m_origStructAddr);
 }
 
 // Private helper function that displays the members of the wrapped struct
-void xgl_render_pass_create_info_struct_wrapper::display_struct_members()
+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    %srenderArea = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.renderArea));
-    printf("%*s    %sframebuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.framebuffer));
-    printf("%*s    %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount));
+    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<colorAttachmentCount; i++) {
-        printf("%*s    %spColorLoadOps[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_ATTACHMENT_LOAD_OP(*m_struct.pColorLoadOps)[i]);
-    }
-    for (i = 0; i<colorAttachmentCount; i++) {
-        printf("%*s    %spColorStoreOps[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_ATTACHMENT_STORE_OP(*m_struct.pColorStoreOps)[i]);
-    }
-    for (i = 0; i<colorAttachmentCount; i++) {
-        printf("%*s    %spColorLoadClearValues[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pColorLoadClearValues)[i]);
+    for (i = 0; i<count; i++) {
+        printf("%*s    %spSamplers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pSamplers)[i]);
     }
-    printf("%*s    %sdepthLoadOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_LOAD_OP(m_struct.depthLoadOp));
-    printf("%*s    %sdepthLoadClearValue = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthLoadClearValue));
-    printf("%*s    %sdepthStoreOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_STORE_OP(m_struct.depthStoreOp));
-    printf("%*s    %sstencilLoadOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_LOAD_OP(m_struct.stencilLoadOp));
-    printf("%*s    %sstencilLoadClearValue = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilLoadClearValue));
-    printf("%*s    %sstencilStoreOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_STORE_OP(m_struct.stencilStoreOp));
 }
 
 // Output all struct elements, each on their own line
-void xgl_render_pass_create_info_struct_wrapper::display_txt()
+void xgl_update_samplers_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_RENDER_PASS_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_render_pass_create_info_struct_wrapper::display_full_txt()
+void xgl_update_samplers_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_RENDER_PASS_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
-    uint32_t i;
-    for (i = 0; i<colorAttachmentCount; i++) {
-            xgl_clear_color_struct_wrapper class0(&(m_struct.pColorLoadClearValues[i]));
-            class0.set_indent(m_indent + 4);
-            class0.display_full_txt();
-    }
-    if (&m_struct.renderArea) {
-        xgl_rect_struct_wrapper class1(&m_struct.renderArea);
-        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_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')
+// 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_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')
+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_descriptor_set_layout_create_info_struct_wrapper::~xgl_descriptor_set_layout_create_info_struct_wrapper() {}
+xgl_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_single_txt()
+void xgl_update_sampler_textures_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %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()
+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    %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));
-    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));
+    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_descriptor_set_layout_create_info_struct_wrapper::display_txt()
+void xgl_update_sampler_textures_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_descriptor_set_layout_create_info_struct_wrapper::display_full_txt()
+void xgl_update_sampler_textures_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_gpu_compatibility_info_struct_wrapper class definition
-xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// 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_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_gpu_compatibility_info_struct_wrapper::~xgl_gpu_compatibility_info_struct_wrapper() {}
+xgl_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_gpu_compatibility_info_struct_wrapper::display_single_txt()
+void xgl_vertex_input_attribute_description_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_GPU_COMPATIBILITY_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_gpu_compatibility_info_struct_wrapper::display_struct_members()
+void xgl_vertex_input_attribute_description_struct_wrapper::display_struct_members()
 {
-    printf("%*s    %scompatibilityFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.compatibilityFlags));
+    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_gpu_compatibility_info_struct_wrapper::display_txt()
+void xgl_vertex_input_attribute_description_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_GPU_COMPATIBILITY_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_gpu_compatibility_info_struct_wrapper::display_full_txt()
+void xgl_vertex_input_attribute_description_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_GPU_COMPATIBILITY_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 
 
-// 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')
+// 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_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+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_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
+xgl_vertex_input_binding_description_struct_wrapper::~xgl_vertex_input_binding_description_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
+void xgl_vertex_input_binding_description_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+    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_memory_alloc_info_struct_wrapper::display_struct_members()
+void xgl_vertex_input_binding_description_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));
+    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_memory_alloc_info_struct_wrapper::display_txt()
+void xgl_vertex_input_binding_description_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_memory_alloc_info_struct_wrapper::display_full_txt()
+void xgl_vertex_input_binding_description_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION 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_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')
+// 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_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')
+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_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {}
+xgl_viewport_struct_wrapper::~xgl_viewport_struct_wrapper() {}
 // Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
+void xgl_viewport_struct_wrapper::display_single_txt()
 {
-    printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+    printf(" %*sXGL_VIEWPORT = %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()
+void xgl_viewport_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");
+    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_physical_gpu_queue_properties_struct_wrapper::display_txt()
+void xgl_viewport_struct_wrapper::display_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    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_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
+void xgl_viewport_struct_wrapper::display_full_txt()
 {
-    printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+    printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
     this->display_struct_members();
 }
 

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 ac2fe0c..6983242 100644 (file)
--- 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,36 +7,31 @@
 #include <stdlib.h>
 
 //class declaration
-class xgl_pipeline_ia_state_create_info_struct_wrapper
+class xgl_alloc_callbacks_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);
+    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_pipeline_ia_state_create_info_struct_wrapper();
+    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; }
-    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; }
+    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_PIPELINE_IA_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_IA_STATE_CREATE_INFO* m_origStructAddr;
+    XGL_ALLOC_CALLBACKS m_struct;
+    const XGL_ALLOC_CALLBACKS* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -83,30 +78,31 @@ private:
 
 
 //class declaration
-class xgl_link_const_buffer_struct_wrapper
+class xgl_buffer_copy_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);
+    xgl_buffer_copy_struct_wrapper();
+    xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct);
+    xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct);
 
-    virtual ~xgl_link_const_buffer_struct_wrapper();
+    virtual ~xgl_buffer_copy_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; }
+    XGL_GPU_SIZE get_srcOffset() { return m_struct.srcOffset; }
+    void set_srcOffset(XGL_GPU_SIZE inValue) { m_struct.srcOffset = inValue; }
+    XGL_GPU_SIZE get_destOffset() { return m_struct.destOffset; }
+    void set_destOffset(XGL_GPU_SIZE inValue) { m_struct.destOffset = inValue; }
+    XGL_GPU_SIZE get_copySize() { return m_struct.copySize; }
+    void set_copySize(XGL_GPU_SIZE inValue) { m_struct.copySize = inValue; }
 
 
 private:
-    XGL_LINK_CONST_BUFFER m_struct;
-    const XGL_LINK_CONST_BUFFER* m_origStructAddr;
+    XGL_BUFFER_COPY m_struct;
+    const XGL_BUFFER_COPY* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -115,14 +111,14 @@ private:
 
 
 //class declaration
-class xgl_update_samplers_struct_wrapper
+class xgl_buffer_create_info_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);
+    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_update_samplers_struct_wrapper();
+    virtual ~xgl_buffer_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -132,50 +128,17 @@ public:
     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; }
+    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_STENCIL_OP_STATE m_struct;
-    const XGL_STENCIL_OP_STATE* 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();
@@ -184,27 +147,33 @@ private:
 
 
 //class declaration
-class xgl_peer_image_open_info_struct_wrapper
+class xgl_buffer_image_copy_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);
+    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_peer_image_open_info_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_IMAGE get_originalImage() { return m_struct.originalImage; }
-    void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = 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_PEER_IMAGE_OPEN_INFO m_struct;
-    const XGL_PEER_IMAGE_OPEN_INFO* 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();
@@ -213,14 +182,14 @@ private:
 
 
 //class declaration
-class xgl_device_create_info_struct_wrapper
+class xgl_buffer_memory_barrier_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);
+    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_device_create_info_struct_wrapper();
+    virtual ~xgl_buffer_memory_barrier_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -230,19 +199,21 @@ public:
     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; }
+    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_DEVICE_CREATE_INFO m_struct;
-    const XGL_DEVICE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -280,14 +251,14 @@ private:
 
 
 //class declaration
-class xgl_update_buffers_struct_wrapper
+class xgl_buffer_view_attach_info_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);
+    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_update_buffers_struct_wrapper();
+    virtual ~xgl_buffer_view_attach_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -297,17 +268,13 @@ public:
     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; }
+    XGL_BUFFER_VIEW get_view() { return m_struct.view; }
+    void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; }
 
 
 private:
-    XGL_UPDATE_BUFFERS m_struct;
-    const XGL_UPDATE_BUFFERS* m_origStructAddr;
+    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();
@@ -316,31 +283,42 @@ private:
 
 
 //class declaration
-class xgl_vertex_input_attribute_description_struct_wrapper
+class xgl_buffer_view_create_info_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);
+    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_vertex_input_attribute_description_struct_wrapper();
+    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; }
-    uint32_t get_binding() { return m_struct.binding; }
-    void set_binding(uint32_t inValue) { m_struct.binding = inValue; }
+    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; }
-    uint32_t get_offsetInBytes() { return m_struct.offsetInBytes; }
-    void set_offsetInBytes(uint32_t inValue) { m_struct.offsetInBytes = 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_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION m_struct;
-    const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* m_origStructAddr;
+    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();
@@ -349,32 +327,33 @@ private:
 
 
 //class declaration
-class xgl_pipeline_vertex_input_create_info_struct_wrapper
+class xgl_channel_mapping_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);
+    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_pipeline_vertex_input_create_info_struct_wrapper();
+    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_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; }
+    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_PIPELINE_VERTEX_INPUT_CREATE_INFO m_struct;
-    const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* m_origStructAddr;
+    XGL_CHANNEL_MAPPING m_struct;
+    const XGL_CHANNEL_MAPPING* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -383,40 +362,29 @@ private:
 
 
 //class declaration
-class xgl_dynamic_rs_state_create_info_struct_wrapper
+class xgl_clear_color_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);
+    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_dynamic_rs_state_create_info_struct_wrapper();
+    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_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; }
+    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_DYNAMIC_RS_STATE_CREATE_INFO m_struct;
-    const XGL_DYNAMIC_RS_STATE_CREATE_INFO* m_origStructAddr;
+    XGL_CLEAR_COLOR m_struct;
+    const XGL_CLEAR_COLOR* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -425,33 +393,25 @@ private:
 
 
 //class declaration
-class xgl_subresource_layout_struct_wrapper
+class xgl_clear_color_value_struct_wrapper
 {
 public:
-    xgl_subresource_layout_struct_wrapper();
-    xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct);
-    xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct);
+    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_subresource_layout_struct_wrapper();
+    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; }
-    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; }
-    XGL_GPU_SIZE get_rowPitch() { return m_struct.rowPitch; }
-    void set_rowPitch(XGL_GPU_SIZE inValue) { m_struct.rowPitch = inValue; }
-    XGL_GPU_SIZE get_depthPitch() { return m_struct.depthPitch; }
-    void set_depthPitch(XGL_GPU_SIZE inValue) { m_struct.depthPitch = inValue; }
 
 
 private:
-    XGL_SUBRESOURCE_LAYOUT m_struct;
-    const XGL_SUBRESOURCE_LAYOUT* m_origStructAddr;
+    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();
@@ -460,35 +420,30 @@ private:
 
 
 //class declaration
-class xgl_draw_indexed_indirect_cmd_struct_wrapper
+class xgl_cmd_buffer_begin_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_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_draw_indexed_indirect_cmd_struct_wrapper();
+    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; }
-    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; }
+    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_DRAW_INDEXED_INDIRECT_CMD m_struct;
-    const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr;
+    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();
@@ -497,14 +452,14 @@ private:
 
 
 //class declaration
-class xgl_dynamic_vp_state_create_info_struct_wrapper
+class xgl_cmd_buffer_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);
+    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_dynamic_vp_state_create_info_struct_wrapper();
+    virtual ~xgl_cmd_buffer_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -514,13 +469,15 @@ public:
     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; }
+    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_DYNAMIC_VP_STATE_CREATE_INFO m_struct;
-    const XGL_DYNAMIC_VP_STATE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -529,14 +486,14 @@ private:
 
 
 //class declaration
-class xgl_shader_create_info_struct_wrapper
+class xgl_cmd_buffer_graphics_begin_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_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_shader_create_info_struct_wrapper();
+    virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -546,16 +503,13 @@ public:
     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_RENDER_PASS get_renderPass() { return m_struct.renderPass; }
+    void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = inValue; }
 
 
 private:
-    XGL_SHADER_CREATE_INFO m_struct;
-    const XGL_SHADER_CREATE_INFO* m_origStructAddr;
+    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();
@@ -564,29 +518,29 @@ private:
 
 
 //class declaration
-class xgl_memory_ref_struct_wrapper
+class xgl_color_attachment_bind_info_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);
+    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_memory_ref_struct_wrapper();
+    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_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; }
+    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_MEMORY_REF m_struct;
-    const XGL_MEMORY_REF* m_origStructAddr;
+    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();
@@ -595,29 +549,42 @@ private:
 
 
 //class declaration
-class xgl_format_properties_struct_wrapper
+class xgl_color_attachment_view_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_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_format_properties_struct_wrapper();
+    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_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; }
+    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_FORMAT_PROPERTIES m_struct;
-    const XGL_FORMAT_PROPERTIES* m_origStructAddr;
+    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();
@@ -626,47 +593,40 @@ private:
 
 
 //class declaration
-class xgl_pipeline_statistics_data_struct_wrapper
+class xgl_compute_pipeline_create_info_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);
+    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_pipeline_statistics_data_struct_wrapper();
+    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; }
-    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; }
+    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_PIPELINE_STATISTICS_DATA m_struct;
-    const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr;
+    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();
@@ -675,31 +635,29 @@ private:
 
 
 //class declaration
-class xgl_alloc_callbacks_struct_wrapper
+class xgl_depth_stencil_bind_info_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);
+    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_alloc_callbacks_struct_wrapper();
+    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; }
-    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; }
+    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_ALLOC_CALLBACKS m_struct;
-    const XGL_ALLOC_CALLBACKS* m_origStructAddr;
+    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();
@@ -708,14 +666,14 @@ private:
 
 
 //class declaration
-class xgl_pipeline_cb_state_create_info_struct_wrapper
+class xgl_depth_stencil_view_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);
+    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_pipeline_cb_state_create_info_struct_wrapper();
+    virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -725,19 +683,25 @@ public:
     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; }
+    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_PIPELINE_CB_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_CB_STATE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -746,33 +710,30 @@ private:
 
 
 //class declaration
-class xgl_draw_indirect_cmd_struct_wrapper
+class xgl_descriptor_region_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_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_draw_indirect_cmd_struct_wrapper();
+    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; }
-    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; }
+    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_DRAW_INDIRECT_CMD m_struct;
-    const XGL_DRAW_INDIRECT_CMD* m_origStructAddr;
+    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();
@@ -781,14 +742,14 @@ private:
 
 
 //class declaration
-class xgl_color_attachment_view_create_info_struct_wrapper
+class xgl_descriptor_set_layout_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);
+    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_color_attachment_view_create_info_struct_wrapper();
+    virtual ~xgl_descriptor_set_layout_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -798,25 +759,19 @@ public:
     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; }
+    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_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct;
-    const XGL_COLOR_ATTACHMENT_VIEW_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();
@@ -825,43 +780,29 @@ private:
 
 
 //class declaration
-class xgl_pipeline_cb_attachment_state_struct_wrapper
+class xgl_descriptor_type_count_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);
+    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_pipeline_cb_attachment_state_struct_wrapper();
+    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; }
-    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; }
+    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_PIPELINE_CB_ATTACHMENT_STATE m_struct;
-    const XGL_PIPELINE_CB_ATTACHMENT_STATE* m_origStructAddr;
+    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();
@@ -870,29 +811,36 @@ private:
 
 
 //class declaration
-class xgl_vertex_input_binding_description_struct_wrapper
+class xgl_device_create_info_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);
+    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_vertex_input_binding_description_struct_wrapper();
+    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; }
-    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; }
+    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_VERTEX_INPUT_BINDING_DESCRIPTION m_struct;
-    const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* m_origStructAddr;
+    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();
@@ -901,30 +849,29 @@ private:
 
 
 //class declaration
-class xgl_pipeline_shader_stage_create_info_struct_wrapper
+class xgl_device_queue_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);
+    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_pipeline_shader_stage_create_info_struct_wrapper();
+    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; }
-    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; }
+    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_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -933,30 +880,31 @@ private:
 
 
 //class declaration
-class xgl_fence_create_info_struct_wrapper
+class xgl_dispatch_indirect_cmd_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_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_fence_create_info_struct_wrapper();
+    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; }
-    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; }
+    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_FENCE_CREATE_INFO m_struct;
-    const XGL_FENCE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -965,39 +913,35 @@ private:
 
 
 //class declaration
-class xgl_framebuffer_create_info_struct_wrapper
+class xgl_draw_indexed_indirect_cmd_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);
+    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_framebuffer_create_info_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_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; }
+    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_FRAMEBUFFER_CREATE_INFO m_struct;
-    const XGL_FRAMEBUFFER_CREATE_INFO* 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();
@@ -1006,29 +950,33 @@ private:
 
 
 //class declaration
-class xgl_extent2d_struct_wrapper
+class xgl_draw_indirect_cmd_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();
+    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; }
-    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; }
+    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_EXTENT2D m_struct;
-    const XGL_EXTENT2D* m_origStructAddr;
+    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();
@@ -1037,14 +985,14 @@ private:
 
 
 //class declaration
-class xgl_compute_pipeline_create_info_struct_wrapper
+class xgl_dynamic_cb_state_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);
+    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_compute_pipeline_create_info_struct_wrapper();
+    virtual ~xgl_dynamic_cb_state_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1054,23 +1002,11 @@ public:
     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;
+    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();
@@ -1079,35 +1015,40 @@ private:
 
 
 //class declaration
-class xgl_image_subresource_range_struct_wrapper
+class xgl_dynamic_ds_state_create_info_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);
+    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_image_subresource_range_struct_wrapper();
+    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_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; }
+    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_IMAGE_SUBRESOURCE_RANGE m_struct;
-    const XGL_IMAGE_SUBRESOURCE_RANGE* m_origStructAddr;
+    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();
@@ -1116,14 +1057,14 @@ private:
 
 
 //class declaration
-class xgl_pipeline_tess_state_create_info_struct_wrapper
+class xgl_dynamic_rs_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);
+    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_pipeline_tess_state_create_info_struct_wrapper();
+    virtual ~xgl_dynamic_rs_state_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1133,17 +1074,23 @@ public:
     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; }
+    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_PIPELINE_TESS_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -1152,29 +1099,30 @@ private:
 
 
 //class declaration
-class xgl_offset2d_struct_wrapper
+class xgl_dynamic_vp_state_create_info_struct_wrapper
 {
 public:
-    xgl_offset2d_struct_wrapper();
-    xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
-    xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
+    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_offset2d_struct_wrapper();
+    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; }
-    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; }
+    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_OFFSET2D m_struct;
-    const XGL_OFFSET2D* m_origStructAddr;
+    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();
@@ -1183,14 +1131,14 @@ private:
 
 
 //class declaration
-class xgl_queue_semaphore_create_info_struct_wrapper
+class xgl_event_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);
+    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_queue_semaphore_create_info_struct_wrapper();
+    virtual ~xgl_event_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1200,15 +1148,13 @@ public:
     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;
+    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();
@@ -1217,25 +1163,34 @@ private:
 
 
 //class declaration
-class xgl_clear_color_value_struct_wrapper
+class xgl_event_wait_info_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);
+    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_clear_color_value_struct_wrapper();
+    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_CLEAR_COLOR_VALUE m_struct;
-    const XGL_CLEAR_COLOR_VALUE* 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();
@@ -1244,38 +1199,29 @@ private:
 
 
 //class declaration
-class xgl_buffer_memory_barrier_struct_wrapper
+class xgl_extent2d_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);
+    xgl_extent2d_struct_wrapper();
+    xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct);
+    xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct);
 
-    virtual ~xgl_buffer_memory_barrier_struct_wrapper();
+    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; }
-    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; }
+    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_BUFFER_MEMORY_BARRIER m_struct;
-    const XGL_BUFFER_MEMORY_BARRIER* m_origStructAddr;
+    XGL_EXTENT2D m_struct;
+    const XGL_EXTENT2D* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1284,38 +1230,31 @@ private:
 
 
 //class declaration
-class xgl_pipeline_ms_state_create_info_struct_wrapper
+class xgl_extent3d_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);
+    xgl_extent3d_struct_wrapper();
+    xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct);
+    xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct);
 
-    virtual ~xgl_pipeline_ms_state_create_info_struct_wrapper();
+    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; }
-    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; }
+    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_PIPELINE_MS_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_MS_STATE_CREATE_INFO* m_origStructAddr;
+    XGL_EXTENT3D m_struct;
+    const XGL_EXTENT3D* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1324,14 +1263,14 @@ private:
 
 
 //class declaration
-class xgl_pipeline_rs_state_create_info_struct_wrapper
+class xgl_fence_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);
+    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_pipeline_rs_state_create_info_struct_wrapper();
+    virtual ~xgl_fence_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1341,75 +1280,13 @@ public:
     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;
+    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();
@@ -1418,34 +1295,29 @@ private:
 
 
 //class declaration
-class xgl_update_images_struct_wrapper
+class xgl_format_properties_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);
+    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_update_images_struct_wrapper();
+    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_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; }
+    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_UPDATE_IMAGES m_struct;
-    const XGL_UPDATE_IMAGES* m_origStructAddr;
+    XGL_FORMAT_PROPERTIES m_struct;
+    const XGL_FORMAT_PROPERTIES* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1454,14 +1326,14 @@ private:
 
 
 //class declaration
-class xgl_cmd_buffer_begin_info_struct_wrapper
+class xgl_framebuffer_create_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);
+    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_cmd_buffer_begin_info_struct_wrapper();
+    virtual ~xgl_framebuffer_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1471,13 +1343,22 @@ public:
     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; }
+    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_CMD_BUFFER_BEGIN_INFO m_struct;
-    const XGL_CMD_BUFFER_BEGIN_INFO* m_origStructAddr;
+    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();
@@ -1486,40 +1367,27 @@ private:
 
 
 //class declaration
-class xgl_image_view_create_info_struct_wrapper
+class xgl_gpu_compatibility_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);
+    xgl_gpu_compatibility_info_struct_wrapper();
+    xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct);
+    xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct);
 
-    virtual ~xgl_image_view_create_info_struct_wrapper();
+    virtual ~xgl_gpu_compatibility_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; }
+    XGL_FLAGS get_compatibilityFlags() { return m_struct.compatibilityFlags; }
+    void set_compatibilityFlags(XGL_FLAGS inValue) { m_struct.compatibilityFlags = inValue; }
 
 
 private:
-    XGL_IMAGE_VIEW_CREATE_INFO m_struct;
-    const XGL_IMAGE_VIEW_CREATE_INFO* m_origStructAddr;
+    XGL_GPU_COMPATIBILITY_INFO m_struct;
+    const XGL_GPU_COMPATIBILITY_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1562,29 +1430,35 @@ private:
 
 
 //class declaration
-class xgl_rect_struct_wrapper
+class xgl_image_copy_struct_wrapper
 {
 public:
-    xgl_rect_struct_wrapper();
-    xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
-    xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
+    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_rect_struct_wrapper();
+    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_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; }
+    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_RECT m_struct;
-    const XGL_RECT* m_origStructAddr;
+    XGL_IMAGE_COPY m_struct;
+    const XGL_IMAGE_COPY* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1593,14 +1467,14 @@ private:
 
 
 //class declaration
-class xgl_cmd_buffer_graphics_begin_info_struct_wrapper
+class xgl_image_create_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);
+    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_cmd_buffer_graphics_begin_info_struct_wrapper();
+    virtual ~xgl_image_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1610,13 +1484,29 @@ public:
     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; }
+    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_CMD_BUFFER_GRAPHICS_BEGIN_INFO m_struct;
-    const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* m_origStructAddr;
+    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();
@@ -1625,29 +1515,40 @@ private:
 
 
 //class declaration
-class xgl_device_queue_create_info_struct_wrapper
+class xgl_image_memory_barrier_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);
+    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_device_queue_create_info_struct_wrapper();
+    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; }
-    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; }
+    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_DEVICE_QUEUE_CREATE_INFO m_struct;
-    const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -1656,68 +1557,31 @@ private:
 
 
 //class declaration
-class xgl_memory_open_info_struct_wrapper
+class xgl_image_memory_bind_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);
+    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_memory_open_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_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; }
+    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_UPDATE_AS_COPY m_struct;
-    const XGL_UPDATE_AS_COPY* 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();
@@ -1726,35 +1590,31 @@ private:
 
 
 //class declaration
-class xgl_image_copy_struct_wrapper
+class xgl_image_memory_requirements_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);
+    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_copy_struct_wrapper();
+    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_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; }
+    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_COPY m_struct;
-    const XGL_IMAGE_COPY* 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();
@@ -1800,29 +1660,31 @@ private:
 
 
 //class declaration
-class xgl_color_attachment_bind_info_struct_wrapper
+class xgl_image_subresource_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_subresource_struct_wrapper();
+    xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct);
+    xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct);
 
-    virtual ~xgl_color_attachment_bind_info_struct_wrapper();
+    virtual ~xgl_image_subresource_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_ASPECT get_aspect() { return m_struct.aspect; }
+    void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
+    uint32_t get_mipLevel() { return m_struct.mipLevel; }
+    void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
+    uint32_t get_arraySlice() { return m_struct.arraySlice; }
+    void set_arraySlice(uint32_t inValue) { m_struct.arraySlice = inValue; }
 
 
 private:
-    XGL_COLOR_ATTACHMENT_BIND_INFO m_struct;
-    const XGL_COLOR_ATTACHMENT_BIND_INFO* m_origStructAddr;
+    XGL_IMAGE_SUBRESOURCE m_struct;
+    const XGL_IMAGE_SUBRESOURCE* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1831,40 +1693,35 @@ private:
 
 
 //class declaration
-class xgl_dynamic_ds_state_create_info_struct_wrapper
+class xgl_image_subresource_range_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);
+    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_dynamic_ds_state_create_info_struct_wrapper();
+    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_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; }
+    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_DYNAMIC_DS_STATE_CREATE_INFO m_struct;
-    const XGL_DYNAMIC_DS_STATE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -1873,14 +1730,14 @@ private:
 
 
 //class declaration
-class xgl_image_memory_barrier_struct_wrapper
+class xgl_image_view_attach_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_image_view_attach_info_struct_wrapper();
+    xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
+    xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
 
-    virtual ~xgl_image_memory_barrier_struct_wrapper();
+    virtual ~xgl_image_view_attach_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1890,23 +1747,15 @@ public:
     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; }
+    XGL_IMAGE_VIEW get_view() { return m_struct.view; }
+    void set_view(XGL_IMAGE_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_IMAGE_MEMORY_BARRIER m_struct;
-    const XGL_IMAGE_MEMORY_BARRIER* m_origStructAddr;
+    XGL_IMAGE_VIEW_ATTACH_INFO m_struct;
+    const XGL_IMAGE_VIEW_ATTACH_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -1915,14 +1764,14 @@ private:
 
 
 //class declaration
-class xgl_pipeline_ds_state_create_info_struct_wrapper
+class xgl_image_view_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);
+    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_pipeline_ds_state_create_info_struct_wrapper();
+    virtual ~xgl_image_view_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1932,27 +1781,23 @@ public:
     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; }
-    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; }
+    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_PIPELINE_DS_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_DS_STATE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -1961,14 +1806,14 @@ private:
 
 
 //class declaration
-class xgl_pipeline_barrier_struct_wrapper
+class xgl_layer_create_info_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);
+    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_pipeline_barrier_struct_wrapper();
+    virtual ~xgl_layer_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -1978,17 +1823,13 @@ public:
     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; }
+    uint32_t get_layerCount() { return m_struct.layerCount; }
+    void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; }
 
 
 private:
-    XGL_PIPELINE_BARRIER m_struct;
-    const XGL_PIPELINE_BARRIER* 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();
@@ -1997,29 +1838,62 @@ private:
 
 
 //class declaration
-class xgl_physical_gpu_memory_properties_struct_wrapper
+class xgl_link_const_buffer_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);
+    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_physical_gpu_memory_properties_struct_wrapper();
+    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; }
-    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; }
+    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_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct;
-    const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr;
+    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_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_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();
@@ -2064,14 +1938,14 @@ private:
 
 
 //class declaration
-class xgl_update_sampler_textures_struct_wrapper
+class xgl_memory_alloc_info_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);
+    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_update_sampler_textures_struct_wrapper();
+    virtual ~xgl_memory_alloc_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2081,15 +1955,19 @@ public:
     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; }
+    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_UPDATE_SAMPLER_TEXTURES m_struct;
-    const XGL_UPDATE_SAMPLER_TEXTURES* 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();
@@ -2098,14 +1976,14 @@ private:
 
 
 //class declaration
-class xgl_peer_memory_open_info_struct_wrapper
+class xgl_memory_barrier_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);
+    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_peer_memory_open_info_struct_wrapper();
+    virtual ~xgl_memory_barrier_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2115,13 +1993,15 @@ public:
     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_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_PEER_MEMORY_OPEN_INFO m_struct;
-    const XGL_PEER_MEMORY_OPEN_INFO* m_origStructAddr;
+    XGL_MEMORY_BARRIER m_struct;
+    const XGL_MEMORY_BARRIER* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2130,29 +2010,30 @@ private:
 
 
 //class declaration
-class xgl_descriptor_type_count_struct_wrapper
+class xgl_memory_open_info_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);
+    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_descriptor_type_count_struct_wrapper();
+    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_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; }
+    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_DESCRIPTOR_TYPE_COUNT m_struct;
-    const XGL_DESCRIPTOR_TYPE_COUNT* m_origStructAddr;
+    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();
@@ -2161,31 +2042,29 @@ private:
 
 
 //class declaration
-class xgl_dispatch_indirect_cmd_struct_wrapper
+class xgl_memory_ref_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);
+    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_dispatch_indirect_cmd_struct_wrapper();
+    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; }
-    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; }
+    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_DISPATCH_INDIRECT_CMD m_struct;
-    const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr;
+    XGL_MEMORY_REF m_struct;
+    const XGL_MEMORY_REF* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2194,30 +2073,35 @@ private:
 
 
 //class declaration
-class xgl_descriptor_region_create_info_struct_wrapper
+class xgl_memory_requirements_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);
+    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_descriptor_region_create_info_struct_wrapper();
+    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_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; }
+    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_DESCRIPTOR_REGION_CREATE_INFO m_struct;
-    const XGL_DESCRIPTOR_REGION_CREATE_INFO* m_origStructAddr;
+    XGL_MEMORY_REQUIREMENTS m_struct;
+    const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2226,37 +2110,29 @@ private:
 
 
 //class declaration
-class xgl_viewport_struct_wrapper
+class xgl_offset2d_struct_wrapper
 {
 public:
-    xgl_viewport_struct_wrapper();
-    xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct);
-    xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct);
+    xgl_offset2d_struct_wrapper();
+    xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
+    xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
 
-    virtual ~xgl_viewport_struct_wrapper();
+    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; }
-    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; }
+    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_VIEWPORT m_struct;
-    const XGL_VIEWPORT* m_origStructAddr;
+    XGL_OFFSET2D m_struct;
+    const XGL_OFFSET2D* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2265,42 +2141,31 @@ private:
 
 
 //class declaration
-class xgl_depth_stencil_view_create_info_struct_wrapper
+class xgl_offset3d_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);
+    xgl_offset3d_struct_wrapper();
+    xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
+    xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
 
-    virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
+    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; }
-    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; }
+    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_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct;
-    const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr;
+    XGL_OFFSET3D m_struct;
+    const XGL_OFFSET3D* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2309,32 +2174,27 @@ private:
 
 
 //class declaration
-class xgl_query_pool_create_info_struct_wrapper
+class xgl_peer_image_open_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);
+    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_query_pool_create_info_struct_wrapper();
+    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_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; }
+    XGL_IMAGE get_originalImage() { return m_struct.originalImage; }
+    void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; }
 
 
 private:
-    XGL_QUERY_POOL_CREATE_INFO m_struct;
-    const XGL_QUERY_POOL_CREATE_INFO* m_origStructAddr;
+    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();
@@ -2343,14 +2203,14 @@ private:
 
 
 //class declaration
-class xgl_cmd_buffer_create_info_struct_wrapper
+class xgl_peer_memory_open_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);
+    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_cmd_buffer_create_info_struct_wrapper();
+    virtual ~xgl_peer_memory_open_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2360,15 +2220,13 @@ public:
     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; }
+    XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; }
+    void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; }
 
 
 private:
-    XGL_CMD_BUFFER_CREATE_INFO m_struct;
-    const XGL_CMD_BUFFER_CREATE_INFO* m_origStructAddr;
+    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();
@@ -2377,29 +2235,29 @@ private:
 
 
 //class declaration
-class xgl_depth_stencil_bind_info_struct_wrapper
+class xgl_physical_gpu_memory_properties_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);
+    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_depth_stencil_bind_info_struct_wrapper();
+    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; }
-    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; }
+    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_DEPTH_STENCIL_BIND_INFO m_struct;
-    const XGL_DEPTH_STENCIL_BIND_INFO* m_origStructAddr;
+    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();
@@ -2408,35 +2266,35 @@ private:
 
 
 //class declaration
-class xgl_memory_requirements_struct_wrapper
+class xgl_physical_gpu_performance_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);
+    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_memory_requirements_struct_wrapper();
+    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; }
-    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; }
+    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_MEMORY_REQUIREMENTS m_struct;
-    const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
+    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();
@@ -2445,30 +2303,53 @@ private:
 
 
 //class declaration
-class xgl_queue_semaphore_open_info_struct_wrapper
+class xgl_physical_gpu_properties_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);
+    xgl_physical_gpu_properties_struct_wrapper();
+    xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
+    xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
 
-    virtual ~xgl_queue_semaphore_open_info_struct_wrapper();
+    virtual ~xgl_physical_gpu_properties_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; }
+    uint32_t get_apiVersion() { return m_struct.apiVersion; }
+    void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
+    uint32_t get_driverVersion() { return m_struct.driverVersion; }
+    void set_driverVersion(uint32_t inValue) { m_struct.driverVersion = inValue; }
+    uint32_t get_vendorId() { return m_struct.vendorId; }
+    void set_vendorId(uint32_t inValue) { m_struct.vendorId = inValue; }
+    uint32_t get_deviceId() { return m_struct.deviceId; }
+    void set_deviceId(uint32_t inValue) { m_struct.deviceId = inValue; }
+    XGL_PHYSICAL_GPU_TYPE get_gpuType() { return m_struct.gpuType; }
+    void set_gpuType(XGL_PHYSICAL_GPU_TYPE inValue) { m_struct.gpuType = inValue; }
+    uint32_t get_maxMemRefsPerSubmission() { return m_struct.maxMemRefsPerSubmission; }
+    void set_maxMemRefsPerSubmission(uint32_t inValue) { m_struct.maxMemRefsPerSubmission = inValue; }
+    XGL_GPU_SIZE get_maxInlineMemoryUpdateSize() { return m_struct.maxInlineMemoryUpdateSize; }
+    void set_maxInlineMemoryUpdateSize(XGL_GPU_SIZE inValue) { m_struct.maxInlineMemoryUpdateSize = inValue; }
+    uint32_t get_maxBoundDescriptorSets() { return m_struct.maxBoundDescriptorSets; }
+    void set_maxBoundDescriptorSets(uint32_t inValue) { m_struct.maxBoundDescriptorSets = inValue; }
+    uint32_t get_maxThreadGroupSize() { return m_struct.maxThreadGroupSize; }
+    void set_maxThreadGroupSize(uint32_t inValue) { m_struct.maxThreadGroupSize = inValue; }
+    uint64_t get_timestampFrequency() { return m_struct.timestampFrequency; }
+    void set_timestampFrequency(uint64_t inValue) { m_struct.timestampFrequency = inValue; }
+    bool32_t get_multiColorAttachmentClears() { return m_struct.multiColorAttachmentClears; }
+    void set_multiColorAttachmentClears(bool32_t inValue) { m_struct.multiColorAttachmentClears = inValue; }
+    uint32_t get_maxDescriptorSets() { return m_struct.maxDescriptorSets; }
+    void set_maxDescriptorSets(uint32_t inValue) { m_struct.maxDescriptorSets = inValue; }
+    uint32_t get_maxViewports() { return m_struct.maxViewports; }
+    void set_maxViewports(uint32_t inValue) { m_struct.maxViewports = inValue; }
+    uint32_t get_maxColorAttachments() { return m_struct.maxColorAttachments; }
+    void set_maxColorAttachments(uint32_t inValue) { m_struct.maxColorAttachments = inValue; }
 
 
 private:
-    XGL_QUEUE_SEMAPHORE_OPEN_INFO m_struct;
-    const XGL_QUEUE_SEMAPHORE_OPEN_INFO* m_origStructAddr;
+    XGL_PHYSICAL_GPU_PROPERTIES m_struct;
+    const XGL_PHYSICAL_GPU_PROPERTIES* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2477,32 +2358,33 @@ private:
 
 
 //class declaration
-class xgl_memory_barrier_struct_wrapper
+class xgl_physical_gpu_queue_properties_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);
+    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_memory_barrier_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; }
-    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_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_MEMORY_BARRIER m_struct;
-    const XGL_MEMORY_BARRIER* 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();
@@ -2511,35 +2393,34 @@ private:
 
 
 //class declaration
-class xgl_physical_gpu_performance_struct_wrapper
+class xgl_pipeline_barrier_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);
+    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_physical_gpu_performance_struct_wrapper();
+    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; }
-    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; }
+    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_PHYSICAL_GPU_PERFORMANCE m_struct;
-    const XGL_PHYSICAL_GPU_PERFORMANCE* m_origStructAddr;
+    XGL_PIPELINE_BARRIER m_struct;
+    const XGL_PIPELINE_BARRIER* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2548,33 +2429,43 @@ private:
 
 
 //class declaration
-class xgl_channel_mapping_struct_wrapper
+class xgl_pipeline_cb_attachment_state_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);
+    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_channel_mapping_struct_wrapper();
+    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; }
-    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; }
+    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_CHANNEL_MAPPING m_struct;
-    const XGL_CHANNEL_MAPPING* m_origStructAddr;
+    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();
@@ -2583,29 +2474,36 @@ private:
 
 
 //class declaration
-class xgl_clear_color_struct_wrapper
+class xgl_pipeline_cb_state_create_info_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_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_clear_color_struct_wrapper();
+    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_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_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_CLEAR_COLOR m_struct;
-    const XGL_CLEAR_COLOR* m_origStructAddr;
+    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();
@@ -2614,14 +2512,14 @@ private:
 
 
 //class declaration
-class xgl_dynamic_cb_state_create_info_struct_wrapper
+class xgl_pipeline_ds_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);
+    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_dynamic_cb_state_create_info_struct_wrapper();
+    virtual ~xgl_pipeline_ds_state_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2631,11 +2529,27 @@ public:
     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_DYNAMIC_CB_STATE_CREATE_INFO m_struct;
-    const XGL_DYNAMIC_CB_STATE_CREATE_INFO* m_origStructAddr;
+    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();
@@ -2644,14 +2558,14 @@ private:
 
 
 //class declaration
-class xgl_buffer_view_create_info_struct_wrapper
+class xgl_pipeline_ia_state_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);
+    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_buffer_view_create_info_struct_wrapper();
+    virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2661,25 +2575,19 @@ public:
     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; }
+    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_BUFFER_VIEW_CREATE_INFO m_struct;
-    const XGL_BUFFER_VIEW_CREATE_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();
@@ -2688,14 +2596,14 @@ private:
 
 
 //class declaration
-class xgl_sampler_create_info_struct_wrapper
+class xgl_pipeline_ms_state_create_info_struct_wrapper
 {
 public:
-    xgl_sampler_create_info_struct_wrapper();
-    xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct);
-    xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct);
+    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_sampler_create_info_struct_wrapper();
+    virtual ~xgl_pipeline_ms_state_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2705,35 +2613,21 @@ public:
     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_TEX_FILTER get_magFilter() { return m_struct.magFilter; }
-    void set_magFilter(XGL_TEX_FILTER inValue) { m_struct.magFilter = inValue; }
-    XGL_TEX_FILTER get_minFilter() { return m_struct.minFilter; }
-    void set_minFilter(XGL_TEX_FILTER inValue) { m_struct.minFilter = inValue; }
-    XGL_TEX_MIPMAP_MODE get_mipMode() { return m_struct.mipMode; }
-    void set_mipMode(XGL_TEX_MIPMAP_MODE inValue) { m_struct.mipMode = inValue; }
-    XGL_TEX_ADDRESS get_addressU() { return m_struct.addressU; }
-    void set_addressU(XGL_TEX_ADDRESS inValue) { m_struct.addressU = inValue; }
-    XGL_TEX_ADDRESS get_addressV() { return m_struct.addressV; }
-    void set_addressV(XGL_TEX_ADDRESS inValue) { m_struct.addressV = inValue; }
-    XGL_TEX_ADDRESS get_addressW() { return m_struct.addressW; }
-    void set_addressW(XGL_TEX_ADDRESS inValue) { m_struct.addressW = inValue; }
-    float get_mipLodBias() { return m_struct.mipLodBias; }
-    void set_mipLodBias(float inValue) { m_struct.mipLodBias = inValue; }
-    uint32_t get_maxAnisotropy() { return m_struct.maxAnisotropy; }
-    void set_maxAnisotropy(uint32_t inValue) { m_struct.maxAnisotropy = inValue; }
-    XGL_COMPARE_FUNC get_compareFunc() { return m_struct.compareFunc; }
-    void set_compareFunc(XGL_COMPARE_FUNC inValue) { m_struct.compareFunc = inValue; }
-    float get_minLod() { return m_struct.minLod; }
-    void set_minLod(float inValue) { m_struct.minLod = inValue; }
-    float get_maxLod() { return m_struct.maxLod; }
-    void set_maxLod(float inValue) { m_struct.maxLod = inValue; }
-    XGL_BORDER_COLOR_TYPE get_borderColorType() { return m_struct.borderColorType; }
-    void set_borderColorType(XGL_BORDER_COLOR_TYPE inValue) { m_struct.borderColorType = inValue; }
+    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_SAMPLER_CREATE_INFO m_struct;
-    const XGL_SAMPLER_CREATE_INFO* m_origStructAddr;
+    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();
@@ -2742,14 +2636,14 @@ private:
 
 
 //class declaration
-class xgl_event_wait_info_struct_wrapper
+class xgl_pipeline_rs_state_create_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);
+    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_event_wait_info_struct_wrapper();
+    virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2759,17 +2653,27 @@ public:
     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; }
+    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_EVENT_WAIT_INFO m_struct;
-    const XGL_EVENT_WAIT_INFO* m_origStructAddr;
+    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();
@@ -2778,33 +2682,31 @@ private:
 
 
 //class declaration
-class xgl_buffer_image_copy_struct_wrapper
+class xgl_pipeline_shader_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);
+    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_buffer_image_copy_struct_wrapper();
+    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_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; }
+    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_BUFFER_IMAGE_COPY m_struct;
-    const XGL_BUFFER_IMAGE_COPY* m_origStructAddr;
+    XGL_PIPELINE_SHADER m_struct;
+    const XGL_PIPELINE_SHADER* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2813,14 +2715,14 @@ private:
 
 
 //class declaration
-class xgl_event_create_info_struct_wrapper
+class xgl_pipeline_shader_stage_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);
+    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_event_create_info_struct_wrapper();
+    virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2830,13 +2732,13 @@ public:
     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_PIPELINE_SHADER get_shader() { return m_struct.shader; }
+    void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; }
 
 
 private:
-    XGL_EVENT_CREATE_INFO m_struct;
-    const XGL_EVENT_CREATE_INFO* m_origStructAddr;
+    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();
@@ -2845,53 +2747,47 @@ private:
 
 
 //class declaration
-class xgl_physical_gpu_properties_struct_wrapper
+class xgl_pipeline_statistics_data_struct_wrapper
 {
 public:
-    xgl_physical_gpu_properties_struct_wrapper();
-    xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
-    xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
+    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_physical_gpu_properties_struct_wrapper();
+    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; }
-    uint32_t get_apiVersion() { return m_struct.apiVersion; }
-    void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
-    uint32_t get_driverVersion() { return m_struct.driverVersion; }
-    void set_driverVersion(uint32_t inValue) { m_struct.driverVersion = inValue; }
-    uint32_t get_vendorId() { return m_struct.vendorId; }
-    void set_vendorId(uint32_t inValue) { m_struct.vendorId = inValue; }
-    uint32_t get_deviceId() { return m_struct.deviceId; }
-    void set_deviceId(uint32_t inValue) { m_struct.deviceId = inValue; }
-    XGL_PHYSICAL_GPU_TYPE get_gpuType() { return m_struct.gpuType; }
-    void set_gpuType(XGL_PHYSICAL_GPU_TYPE inValue) { m_struct.gpuType = inValue; }
-    uint32_t get_maxMemRefsPerSubmission() { return m_struct.maxMemRefsPerSubmission; }
-    void set_maxMemRefsPerSubmission(uint32_t inValue) { m_struct.maxMemRefsPerSubmission = inValue; }
-    XGL_GPU_SIZE get_maxInlineMemoryUpdateSize() { return m_struct.maxInlineMemoryUpdateSize; }
-    void set_maxInlineMemoryUpdateSize(XGL_GPU_SIZE inValue) { m_struct.maxInlineMemoryUpdateSize = inValue; }
-    uint32_t get_maxBoundDescriptorSets() { return m_struct.maxBoundDescriptorSets; }
-    void set_maxBoundDescriptorSets(uint32_t inValue) { m_struct.maxBoundDescriptorSets = inValue; }
-    uint32_t get_maxThreadGroupSize() { return m_struct.maxThreadGroupSize; }
-    void set_maxThreadGroupSize(uint32_t inValue) { m_struct.maxThreadGroupSize = inValue; }
-    uint64_t get_timestampFrequency() { return m_struct.timestampFrequency; }
-    void set_timestampFrequency(uint64_t inValue) { m_struct.timestampFrequency = inValue; }
-    bool32_t get_multiColorAttachmentClears() { return m_struct.multiColorAttachmentClears; }
-    void set_multiColorAttachmentClears(bool32_t inValue) { m_struct.multiColorAttachmentClears = inValue; }
-    uint32_t get_maxDescriptorSets() { return m_struct.maxDescriptorSets; }
-    void set_maxDescriptorSets(uint32_t inValue) { m_struct.maxDescriptorSets = inValue; }
-    uint32_t get_maxViewports() { return m_struct.maxViewports; }
-    void set_maxViewports(uint32_t inValue) { m_struct.maxViewports = inValue; }
-    uint32_t get_maxColorAttachments() { return m_struct.maxColorAttachments; }
-    void set_maxColorAttachments(uint32_t inValue) { m_struct.maxColorAttachments = inValue; }
+    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_PHYSICAL_GPU_PROPERTIES m_struct;
-    const XGL_PHYSICAL_GPU_PROPERTIES* m_origStructAddr;
+    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();
@@ -2900,14 +2796,14 @@ private:
 
 
 //class declaration
-class xgl_image_view_attach_info_struct_wrapper
+class xgl_pipeline_tess_state_create_info_struct_wrapper
 {
 public:
-    xgl_image_view_attach_info_struct_wrapper();
-    xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
-    xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
+    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_image_view_attach_info_struct_wrapper();
+    virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2917,15 +2813,87 @@ public:
     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_VIEW get_view() { return m_struct.view; }
-    void set_view(XGL_IMAGE_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; }
+    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_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_pipeline_vp_state_create_info_struct_wrapper
+{
+public:
+    xgl_pipeline_vp_state_create_info_struct_wrapper();
+    xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct);
+    xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct);
+
+    virtual ~xgl_pipeline_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_numViewports() { return m_struct.numViewports; }
+    void set_numViewports(uint32_t inValue) { m_struct.numViewports = inValue; }
+    XGL_COORDINATE_ORIGIN get_clipOrigin() { return m_struct.clipOrigin; }
+    void set_clipOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.clipOrigin = inValue; }
+    XGL_DEPTH_MODE get_depthMode() { return m_struct.depthMode; }
+    void set_depthMode(XGL_DEPTH_MODE inValue) { m_struct.depthMode = inValue; }
 
 
 private:
-    XGL_IMAGE_VIEW_ATTACH_INFO m_struct;
-    const XGL_IMAGE_VIEW_ATTACH_INFO* m_origStructAddr;
+    XGL_PIPELINE_VP_STATE_CREATE_INFO m_struct;
+    const XGL_PIPELINE_VP_STATE_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -2934,14 +2902,14 @@ private:
 
 
 //class declaration
-class xgl_memory_alloc_buffer_info_struct_wrapper
+class xgl_query_pool_create_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);
+    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_memory_alloc_buffer_info_struct_wrapper();
+    virtual ~xgl_query_pool_create_info_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -2951,13 +2919,15 @@ public:
     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_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_MEMORY_ALLOC_BUFFER_INFO m_struct;
-    const XGL_MEMORY_ALLOC_BUFFER_INFO* m_origStructAddr;
+    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();
@@ -2966,31 +2936,32 @@ private:
 
 
 //class declaration
-class xgl_buffer_copy_struct_wrapper
+class xgl_queue_semaphore_create_info_struct_wrapper
 {
 public:
-    xgl_buffer_copy_struct_wrapper();
-    xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct);
-    xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct);
+    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_buffer_copy_struct_wrapper();
+    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_GPU_SIZE get_srcOffset() { return m_struct.srcOffset; }
-    void set_srcOffset(XGL_GPU_SIZE inValue) { m_struct.srcOffset = inValue; }
-    XGL_GPU_SIZE get_destOffset() { return m_struct.destOffset; }
-    void set_destOffset(XGL_GPU_SIZE inValue) { m_struct.destOffset = inValue; }
-    XGL_GPU_SIZE get_copySize() { return m_struct.copySize; }
-    void set_copySize(XGL_GPU_SIZE inValue) { m_struct.copySize = inValue; }
+    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_BUFFER_COPY m_struct;
-    const XGL_BUFFER_COPY* m_origStructAddr;
+    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();
@@ -2999,31 +2970,30 @@ private:
 
 
 //class declaration
-class xgl_image_memory_bind_info_struct_wrapper
+class xgl_queue_semaphore_open_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);
+    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_image_memory_bind_info_struct_wrapper();
+    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_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; }
+    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_IMAGE_MEMORY_BIND_INFO m_struct;
-    const XGL_IMAGE_MEMORY_BIND_INFO* m_origStructAddr;
+    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();
@@ -3032,31 +3002,29 @@ private:
 
 
 //class declaration
-class xgl_image_memory_requirements_struct_wrapper
+class xgl_rect_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);
+    xgl_rect_struct_wrapper();
+    xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
+    xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
 
-    virtual ~xgl_image_memory_requirements_struct_wrapper();
+    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_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; }
+    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_IMAGE_MEMORY_REQUIREMENTS m_struct;
-    const XGL_IMAGE_MEMORY_REQUIREMENTS* m_origStructAddr;
+    XGL_RECT m_struct;
+    const XGL_RECT* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -3065,31 +3033,46 @@ private:
 
 
 //class declaration
-class xgl_pipeline_shader_struct_wrapper
+class xgl_render_pass_create_info_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);
+    xgl_render_pass_create_info_struct_wrapper();
+    xgl_render_pass_create_info_struct_wrapper(XGL_RENDER_PASS_CREATE_INFO* pInStruct);
+    xgl_render_pass_create_info_struct_wrapper(const XGL_RENDER_PASS_CREATE_INFO* pInStruct);
 
-    virtual ~xgl_pipeline_shader_struct_wrapper();
+    virtual ~xgl_render_pass_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_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; }
+    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_RECT get_renderArea() { return m_struct.renderArea; }
+    void set_renderArea(XGL_RECT inValue) { m_struct.renderArea = inValue; }
+    XGL_FRAMEBUFFER get_framebuffer() { return m_struct.framebuffer; }
+    void set_framebuffer(XGL_FRAMEBUFFER inValue) { m_struct.framebuffer = inValue; }
+    uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
+    void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
+    XGL_ATTACHMENT_LOAD_OP get_depthLoadOp() { return m_struct.depthLoadOp; }
+    void set_depthLoadOp(XGL_ATTACHMENT_LOAD_OP inValue) { m_struct.depthLoadOp = inValue; }
+    float get_depthLoadClearValue() { return m_struct.depthLoadClearValue; }
+    void set_depthLoadClearValue(float inValue) { m_struct.depthLoadClearValue = inValue; }
+    XGL_ATTACHMENT_STORE_OP get_depthStoreOp() { return m_struct.depthStoreOp; }
+    void set_depthStoreOp(XGL_ATTACHMENT_STORE_OP inValue) { m_struct.depthStoreOp = inValue; }
+    XGL_ATTACHMENT_LOAD_OP get_stencilLoadOp() { return m_struct.stencilLoadOp; }
+    void set_stencilLoadOp(XGL_ATTACHMENT_LOAD_OP inValue) { m_struct.stencilLoadOp = inValue; }
+    uint32_t get_stencilLoadClearValue() { return m_struct.stencilLoadClearValue; }
+    void set_stencilLoadClearValue(uint32_t inValue) { m_struct.stencilLoadClearValue = inValue; }
+    XGL_ATTACHMENT_STORE_OP get_stencilStoreOp() { return m_struct.stencilStoreOp; }
+    void set_stencilStoreOp(XGL_ATTACHMENT_STORE_OP inValue) { m_struct.stencilStoreOp = inValue; }
 
 
 private:
-    XGL_PIPELINE_SHADER m_struct;
-    const XGL_PIPELINE_SHADER* m_origStructAddr;
+    XGL_RENDER_PASS_CREATE_INFO m_struct;
+    const XGL_RENDER_PASS_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -3098,31 +3081,52 @@ private:
 
 
 //class declaration
-class xgl_offset3d_struct_wrapper
+class xgl_sampler_create_info_struct_wrapper
 {
 public:
-    xgl_offset3d_struct_wrapper();
-    xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
-    xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
+    xgl_sampler_create_info_struct_wrapper();
+    xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct);
+    xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct);
 
-    virtual ~xgl_offset3d_struct_wrapper();
+    virtual ~xgl_sampler_create_info_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; }
+    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_TEX_FILTER get_magFilter() { return m_struct.magFilter; }
+    void set_magFilter(XGL_TEX_FILTER inValue) { m_struct.magFilter = inValue; }
+    XGL_TEX_FILTER get_minFilter() { return m_struct.minFilter; }
+    void set_minFilter(XGL_TEX_FILTER inValue) { m_struct.minFilter = inValue; }
+    XGL_TEX_MIPMAP_MODE get_mipMode() { return m_struct.mipMode; }
+    void set_mipMode(XGL_TEX_MIPMAP_MODE inValue) { m_struct.mipMode = inValue; }
+    XGL_TEX_ADDRESS get_addressU() { return m_struct.addressU; }
+    void set_addressU(XGL_TEX_ADDRESS inValue) { m_struct.addressU = inValue; }
+    XGL_TEX_ADDRESS get_addressV() { return m_struct.addressV; }
+    void set_addressV(XGL_TEX_ADDRESS inValue) { m_struct.addressV = inValue; }
+    XGL_TEX_ADDRESS get_addressW() { return m_struct.addressW; }
+    void set_addressW(XGL_TEX_ADDRESS inValue) { m_struct.addressW = inValue; }
+    float get_mipLodBias() { return m_struct.mipLodBias; }
+    void set_mipLodBias(float inValue) { m_struct.mipLodBias = inValue; }
+    uint32_t get_maxAnisotropy() { return m_struct.maxAnisotropy; }
+    void set_maxAnisotropy(uint32_t inValue) { m_struct.maxAnisotropy = inValue; }
+    XGL_COMPARE_FUNC get_compareFunc() { return m_struct.compareFunc; }
+    void set_compareFunc(XGL_COMPARE_FUNC inValue) { m_struct.compareFunc = inValue; }
+    float get_minLod() { return m_struct.minLod; }
+    void set_minLod(float inValue) { m_struct.minLod = inValue; }
+    float get_maxLod() { return m_struct.maxLod; }
+    void set_maxLod(float inValue) { m_struct.maxLod = inValue; }
+    XGL_BORDER_COLOR_TYPE get_borderColorType() { return m_struct.borderColorType; }
+    void set_borderColorType(XGL_BORDER_COLOR_TYPE inValue) { m_struct.borderColorType = inValue; }
 
 
 private:
-    XGL_OFFSET3D m_struct;
-    const XGL_OFFSET3D* m_origStructAddr;
+    XGL_SAMPLER_CREATE_INFO m_struct;
+    const XGL_SAMPLER_CREATE_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -3131,30 +3135,28 @@ private:
 
 
 //class declaration
-class xgl_buffer_view_attach_info_struct_wrapper
+class xgl_sampler_image_view_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);
+    xgl_sampler_image_view_info_struct_wrapper();
+    xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct);
+    xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct);
 
-    virtual ~xgl_buffer_view_attach_info_struct_wrapper();
+    virtual ~xgl_sampler_image_view_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; }
+    XGL_SAMPLER get_pSampler() { return m_struct.pSampler; }
+    void set_pSampler(XGL_SAMPLER inValue) { m_struct.pSampler = inValue; }
+    const XGL_IMAGE_VIEW_ATTACH_INFO* get_pImageView() { return m_struct.pImageView; }
 
 
 private:
-    XGL_BUFFER_VIEW_ATTACH_INFO m_struct;
-    const XGL_BUFFER_VIEW_ATTACH_INFO* m_origStructAddr;
+    XGL_SAMPLER_IMAGE_VIEW_INFO m_struct;
+    const XGL_SAMPLER_IMAGE_VIEW_INFO* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -3163,31 +3165,33 @@ private:
 
 
 //class declaration
-class xgl_extent3d_struct_wrapper
+class xgl_shader_create_info_struct_wrapper
 {
 public:
-    xgl_extent3d_struct_wrapper();
-    xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct);
-    xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct);
+    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_extent3d_struct_wrapper();
+    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; }
-    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; }
+    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_EXTENT3D m_struct;
-    const XGL_EXTENT3D* m_origStructAddr;
+    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();
@@ -3196,28 +3200,33 @@ private:
 
 
 //class declaration
-class xgl_sampler_image_view_info_struct_wrapper
+class xgl_stencil_op_state_struct_wrapper
 {
 public:
-    xgl_sampler_image_view_info_struct_wrapper();
-    xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct);
-    xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct);
+    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_sampler_image_view_info_struct_wrapper();
+    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_SAMPLER get_pSampler() { return m_struct.pSampler; }
-    void set_pSampler(XGL_SAMPLER inValue) { m_struct.pSampler = inValue; }
-    const XGL_IMAGE_VIEW_ATTACH_INFO* get_pImageView() { return m_struct.pImageView; }
+    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_SAMPLER_IMAGE_VIEW_INFO m_struct;
-    const XGL_SAMPLER_IMAGE_VIEW_INFO* m_origStructAddr;
+    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();
@@ -3226,31 +3235,33 @@ private:
 
 
 //class declaration
-class xgl_image_subresource_struct_wrapper
+class xgl_subresource_layout_struct_wrapper
 {
 public:
-    xgl_image_subresource_struct_wrapper();
-    xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct);
-    xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct);
+    xgl_subresource_layout_struct_wrapper();
+    xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct);
+    xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct);
 
-    virtual ~xgl_image_subresource_struct_wrapper();
+    virtual ~xgl_subresource_layout_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_mipLevel() { return m_struct.mipLevel; }
-    void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
-    uint32_t get_arraySlice() { return m_struct.arraySlice; }
-    void set_arraySlice(uint32_t inValue) { m_struct.arraySlice = 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; }
+    XGL_GPU_SIZE get_rowPitch() { return m_struct.rowPitch; }
+    void set_rowPitch(XGL_GPU_SIZE inValue) { m_struct.rowPitch = inValue; }
+    XGL_GPU_SIZE get_depthPitch() { return m_struct.depthPitch; }
+    void set_depthPitch(XGL_GPU_SIZE inValue) { m_struct.depthPitch = inValue; }
 
 
 private:
-    XGL_IMAGE_SUBRESOURCE m_struct;
-    const XGL_IMAGE_SUBRESOURCE* m_origStructAddr;
+    XGL_SUBRESOURCE_LAYOUT m_struct;
+    const XGL_SUBRESOURCE_LAYOUT* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -3259,14 +3270,14 @@ private:
 
 
 //class declaration
-class xgl_layer_create_info_struct_wrapper
+class xgl_update_as_copy_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);
+    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_layer_create_info_struct_wrapper();
+    virtual ~xgl_update_as_copy_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -3276,13 +3287,19 @@ public:
     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; }
+    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_LAYER_CREATE_INFO m_struct;
-    const XGL_LAYER_CREATE_INFO* m_origStructAddr;
+    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();
@@ -3291,14 +3308,14 @@ private:
 
 
 //class declaration
-class xgl_pipeline_vp_state_create_info_struct_wrapper
+class xgl_update_buffers_struct_wrapper
 {
 public:
-    xgl_pipeline_vp_state_create_info_struct_wrapper();
-    xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct);
-    xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct);
+    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_pipeline_vp_state_create_info_struct_wrapper();
+    virtual ~xgl_update_buffers_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -3308,17 +3325,17 @@ public:
     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_numViewports() { return m_struct.numViewports; }
-    void set_numViewports(uint32_t inValue) { m_struct.numViewports = inValue; }
-    XGL_COORDINATE_ORIGIN get_clipOrigin() { return m_struct.clipOrigin; }
-    void set_clipOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.clipOrigin = inValue; }
-    XGL_DEPTH_MODE get_depthMode() { return m_struct.depthMode; }
-    void set_depthMode(XGL_DEPTH_MODE inValue) { m_struct.depthMode = inValue; }
+    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_PIPELINE_VP_STATE_CREATE_INFO m_struct;
-    const XGL_PIPELINE_VP_STATE_CREATE_INFO* m_origStructAddr;
+    XGL_UPDATE_BUFFERS m_struct;
+    const XGL_UPDATE_BUFFERS* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -3327,14 +3344,14 @@ private:
 
 
 //class declaration
-class xgl_buffer_create_info_struct_wrapper
+class xgl_update_images_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);
+    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_buffer_create_info_struct_wrapper();
+    virtual ~xgl_update_images_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -3344,17 +3361,17 @@ public:
     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; }
+    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_BUFFER_CREATE_INFO m_struct;
-    const XGL_BUFFER_CREATE_INFO* m_origStructAddr;
+    XGL_UPDATE_IMAGES m_struct;
+    const XGL_UPDATE_IMAGES* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -3363,14 +3380,14 @@ private:
 
 
 //class declaration
-class xgl_render_pass_create_info_struct_wrapper
+class xgl_update_samplers_struct_wrapper
 {
 public:
-    xgl_render_pass_create_info_struct_wrapper();
-    xgl_render_pass_create_info_struct_wrapper(XGL_RENDER_PASS_CREATE_INFO* pInStruct);
-    xgl_render_pass_create_info_struct_wrapper(const XGL_RENDER_PASS_CREATE_INFO* pInStruct);
+    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_render_pass_create_info_struct_wrapper();
+    virtual ~xgl_update_samplers_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -3380,29 +3397,15 @@ public:
     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_RECT get_renderArea() { return m_struct.renderArea; }
-    void set_renderArea(XGL_RECT inValue) { m_struct.renderArea = inValue; }
-    XGL_FRAMEBUFFER get_framebuffer() { return m_struct.framebuffer; }
-    void set_framebuffer(XGL_FRAMEBUFFER inValue) { m_struct.framebuffer = inValue; }
-    uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
-    void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
-    XGL_ATTACHMENT_LOAD_OP get_depthLoadOp() { return m_struct.depthLoadOp; }
-    void set_depthLoadOp(XGL_ATTACHMENT_LOAD_OP inValue) { m_struct.depthLoadOp = inValue; }
-    float get_depthLoadClearValue() { return m_struct.depthLoadClearValue; }
-    void set_depthLoadClearValue(float inValue) { m_struct.depthLoadClearValue = inValue; }
-    XGL_ATTACHMENT_STORE_OP get_depthStoreOp() { return m_struct.depthStoreOp; }
-    void set_depthStoreOp(XGL_ATTACHMENT_STORE_OP inValue) { m_struct.depthStoreOp = inValue; }
-    XGL_ATTACHMENT_LOAD_OP get_stencilLoadOp() { return m_struct.stencilLoadOp; }
-    void set_stencilLoadOp(XGL_ATTACHMENT_LOAD_OP inValue) { m_struct.stencilLoadOp = inValue; }
-    uint32_t get_stencilLoadClearValue() { return m_struct.stencilLoadClearValue; }
-    void set_stencilLoadClearValue(uint32_t inValue) { m_struct.stencilLoadClearValue = inValue; }
-    XGL_ATTACHMENT_STORE_OP get_stencilStoreOp() { return m_struct.stencilStoreOp; }
-    void set_stencilStoreOp(XGL_ATTACHMENT_STORE_OP inValue) { m_struct.stencilStoreOp = 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_RENDER_PASS_CREATE_INFO m_struct;
-    const XGL_RENDER_PASS_CREATE_INFO* m_origStructAddr;
+    XGL_UPDATE_SAMPLERS m_struct;
+    const XGL_UPDATE_SAMPLERS* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();
@@ -3411,14 +3414,14 @@ private:
 
 
 //class declaration
-class xgl_descriptor_set_layout_create_info_struct_wrapper
+class xgl_update_sampler_textures_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);
+    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_descriptor_set_layout_create_info_struct_wrapper();
+    virtual ~xgl_update_sampler_textures_struct_wrapper();
 
     void display_txt();
     void display_single_txt();
@@ -3428,19 +3431,15 @@ public:
     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; }
-    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;
+    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();
@@ -3449,27 +3448,31 @@ private:
 
 
 //class declaration
-class xgl_gpu_compatibility_info_struct_wrapper
+class xgl_vertex_input_attribute_description_struct_wrapper
 {
 public:
-    xgl_gpu_compatibility_info_struct_wrapper();
-    xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct);
-    xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct);
+    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_gpu_compatibility_info_struct_wrapper();
+    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; }
-    XGL_FLAGS get_compatibilityFlags() { return m_struct.compatibilityFlags; }
-    void set_compatibilityFlags(XGL_FLAGS inValue) { m_struct.compatibilityFlags = inValue; }
+    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_GPU_COMPATIBILITY_INFO m_struct;
-    const XGL_GPU_COMPATIBILITY_INFO* m_origStructAddr;
+    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();
@@ -3478,36 +3481,29 @@ private:
 
 
 //class declaration
-class xgl_memory_alloc_info_struct_wrapper
+class xgl_vertex_input_binding_description_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);
+    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_memory_alloc_info_struct_wrapper();
+    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; }
-    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; }
+    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_MEMORY_ALLOC_INFO m_struct;
-    const XGL_MEMORY_ALLOC_INFO* m_origStructAddr;
+    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();
@@ -3516,33 +3512,37 @@ private:
 
 
 //class declaration
-class xgl_physical_gpu_queue_properties_struct_wrapper
+class xgl_viewport_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_viewport_struct_wrapper();
+    xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct);
+    xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct);
 
-    virtual ~xgl_physical_gpu_queue_properties_struct_wrapper();
+    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; }
-    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; }
+    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_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct;
-    const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr;
+    XGL_VIEWPORT m_struct;
+    const XGL_VIEWPORT* m_origStructAddr;
     uint32_t m_indent;
     const char m_dummy_prefix;
     void display_struct_members();