From 56782cd5af7f7788ce0d80524be016321c6c07f0 Mon Sep 17 00:00:00 2001 From: Peter Lohrmann Date: Fri, 27 Mar 2015 12:57:10 -0700 Subject: [PATCH] glave: rename codegen'd files to better reflect where they are used. * Several of the filenames started with glvtrace_* but are also used by glvreplay and glvdebug because they are related to trace packet structures, which must be shared. * Also rename the generated files from 'xgl' to 'vk' (at least those that are related to glave. I didn't rename the once that come from the driver's scripts). * There were a few manually written files that needed to have updated includes due to the name changes. --- tools/glave/scripts/vk_generate.py | 28 +- .../src/glv_extensions/glvdebug_xgl/CMakeLists.txt | 24 +- ...glvtrace_xgl_packet_id.h => glv_vk_packet_id.h} | 6 +- .../codegen/glv_vk_vk_structs.h} | 0 .../codegen/glv_vk_vkdbg_structs.h} | 0 .../codegen/glv_vk_vkwsix11ext_structs.h} | 0 .../glvdebug_xgl/codegen/xgl_enum_string_helper.h | 2044 +++++----- .../codegen/xgl_enum_validate_helper.h | 1134 +++--- .../glvdebug_xgl/glvdebug_xgl_qcontroller.cpp | 2 +- .../glvdebug_xgl_qgroupframesproxymodel.h | 2 +- .../glv_extensions/glvreplay_xgl/CMakeLists.txt | 24 +- .../codegen/glv_vk_packet_id.h} | 6 +- ...trace_xgl_xgl_structs.h => glv_vk_vk_structs.h} | 0 ...xgl_xgldbg_structs.h => glv_vk_vkdbg_structs.h} | 0 ...1ext_structs.h => glv_vk_vkwsix11ext_structs.h} | 0 .../glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp | 136 +- .../glvreplay_xgl/codegen/glvreplay_xgl_replay.h | 188 +- .../glvreplay_xgl/codegen/xgl_enum_string_helper.h | 1894 +++++----- .../codegen/xgl_enum_validate_helper.h | 1194 +++--- .../glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp | 2 +- .../src/glv_extensions/glvtrace_xgl/CMakeLists.txt | 24 +- .../codegen/glv_vk_packet_id.h} | 6 +- .../codegen/glv_vk_vk_structs.h} | 0 .../codegen/glv_vk_vkdbg_structs.h} | 0 .../codegen/glv_vk_vkwsix11ext_structs.h} | 0 .../glvtrace_xgl/codegen/glvtrace_xgl_xgl.h | 4 +- .../glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c | 4 +- .../codegen/glvtrace_xgl_xglwsix11ext.c | 4 +- .../glvtrace_xgl/codegen/xgl_enum_string_helper.h | 2512 ++++++------ .../codegen/xgl_enum_validate_helper.h | 1594 ++++---- .../glvtrace_xgl/codegen/xgl_struct_size_helper.h | 690 ++-- .../codegen/xgl_struct_string_helper.h | 1406 +++---- .../codegen/xgl_struct_string_helper_no_addr.h | 1406 +++---- .../codegen/xgl_struct_validate_helper.h | 762 ++-- .../glvtrace_xgl/codegen/xgl_struct_wrappers.cpp | 3980 ++++++++++---------- .../glvtrace_xgl/codegen/xgl_struct_wrappers.h | 2858 +++++++------- 36 files changed, 11070 insertions(+), 10864 deletions(-) rename tools/glave/src/glv_extensions/glvdebug_xgl/codegen/{glvtrace_xgl_packet_id.h => glv_vk_packet_id.h} (99%) rename tools/glave/src/glv_extensions/{glvtrace_xgl/codegen/glvtrace_xgl_xgl_structs.h => glvdebug_xgl/codegen/glv_vk_vk_structs.h} (100%) rename tools/glave/src/glv_extensions/{glvtrace_xgl/codegen/glvtrace_xgl_xgldbg_structs.h => glvdebug_xgl/codegen/glv_vk_vkdbg_structs.h} (100%) rename tools/glave/src/glv_extensions/{glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h => glvdebug_xgl/codegen/glv_vk_vkwsix11ext_structs.h} (100%) rename tools/glave/src/glv_extensions/{glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h => glvreplay_xgl/codegen/glv_vk_packet_id.h} (99%) rename tools/glave/src/glv_extensions/glvreplay_xgl/codegen/{glvtrace_xgl_xgl_structs.h => glv_vk_vk_structs.h} (100%) rename tools/glave/src/glv_extensions/glvreplay_xgl/codegen/{glvtrace_xgl_xgldbg_structs.h => glv_vk_vkdbg_structs.h} (100%) rename tools/glave/src/glv_extensions/glvreplay_xgl/codegen/{glvtrace_xgl_xglwsix11ext_structs.h => glv_vk_vkwsix11ext_structs.h} (100%) rename tools/glave/src/glv_extensions/{glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h => glvtrace_xgl/codegen/glv_vk_packet_id.h} (99%) rename tools/glave/src/glv_extensions/{glvdebug_xgl/codegen/glvtrace_xgl_xgl_structs.h => glvtrace_xgl/codegen/glv_vk_vk_structs.h} (100%) rename tools/glave/src/glv_extensions/{glvdebug_xgl/codegen/glvtrace_xgl_xgldbg_structs.h => glvtrace_xgl/codegen/glv_vk_vkdbg_structs.h} (100%) rename tools/glave/src/glv_extensions/{glvdebug_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h => glvtrace_xgl/codegen/glv_vk_vkwsix11ext_structs.h} (100%) diff --git a/tools/glave/scripts/vk_generate.py b/tools/glave/scripts/vk_generate.py index e96dc7c..bec34ed 100755 --- a/tools/glave/scripts/vk_generate.py +++ b/tools/glave/scripts/vk_generate.py @@ -1387,7 +1387,7 @@ class Subcommand(object): return "\n".join(pid_enum) # Interpret functions used on replay to read in packets and interpret their contents - # This code gets generated into glvtrace_xgl_xgl_structs.h file + # This code gets generated into glv_vk_vk_structs.h file def _generate_interp_funcs(self): # Custom txt for given function and parameter. First check if param is NULL, then insert txt if not # TODO : This code is now too large and complex, need to make codegen smarter for pointers embedded in struct params to handle those cases automatically @@ -3341,8 +3341,8 @@ class Subcommand(object): class GlaveTraceHeader(Subcommand): def generate_header(self): header_txt = [] - header_txt.append('#include "glvtrace_xgl_xgl_structs.h"') - header_txt.append('#include "glvtrace_xgl_packet_id.h"\n') + header_txt.append('#include "glv_vk_vk_structs.h"') + header_txt.append('#include "glv_vk_packet_id.h"\n') header_txt.append('void AttachHooks();') header_txt.append('void DetachHooks();') header_txt.append('void InitTracer(void);\n') @@ -3389,9 +3389,9 @@ class GlavePacketID(Subcommand): header_txt.append('#include "glv_trace_packet_utils.h"') header_txt.append('#include "glv_trace_packet_identifiers.h"') header_txt.append('#include "glv_interconnect.h"') - header_txt.append('#include "glvtrace_xgl_xgl_structs.h"') - header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"') - header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"') + header_txt.append('#include "glv_vk_vk_structs.h"') + header_txt.append('#include "glv_vk_vkdbg_structs.h"') + header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"') header_txt.append('#include "xgl_enum_string_helper.h"') header_txt.append('#if defined(WIN32)') header_txt.append('#define snprintf _snprintf') @@ -3455,8 +3455,8 @@ class GlaveWsiC(Subcommand): header_txt.append('#include "glv_platform.h"') header_txt.append('#include "glv_common.h"') header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"') - header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"') - header_txt.append('#include "glvtrace_xgl_packet_id.h"') + header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"') + header_txt.append('#include "glv_vk_packet_id.h"') header_txt.append('#ifdef WIN32') header_txt.append('#include "mhook/mhook-lib/mhook.h"') header_txt.append('#endif') @@ -3510,8 +3510,8 @@ class GlaveDbgC(Subcommand): header_txt.append('#include "glv_common.h"') header_txt.append('#include "glvtrace_xgl_xgl.h"') header_txt.append('#include "glvtrace_xgl_xgldbg.h"') - header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"') - header_txt.append('#include "glvtrace_xgl_packet_id.h"') + header_txt.append('#include "glv_vk_vkdbg_structs.h"') + header_txt.append('#include "glv_vk_packet_id.h"') header_txt.append('#ifdef WIN32') header_txt.append('#include "mhook/mhook-lib/mhook.h"') header_txt.append('#endif') @@ -3581,10 +3581,10 @@ class GlaveReplayC(Subcommand): header_txt.append('#include ') header_txt.append('glvreplay_settings *g_pReplaySettings;') header_txt.append('extern "C" {') - header_txt.append('#include "glvtrace_xgl_xgl_structs.h"') - header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"') - header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"') - header_txt.append('#include "glvtrace_xgl_packet_id.h"') + header_txt.append('#include "glv_vk_vk_structs.h"') + header_txt.append('#include "glv_vk_vkdbg_structs.h"') + header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"') + header_txt.append('#include "glv_vk_packet_id.h"') header_txt.append('#include "xgl_enum_string_helper.h"\n}\n') header_txt.append('#define APP_NAME "glvreplay_xgl"') header_txt.append('#define IDI_ICON 101\n') diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt index 589cf66..89d5fa9 100644 --- a/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt +++ b/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt @@ -20,15 +20,15 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR} ${SRC_DIR}/../../../include) file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen) -add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h +add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen DEPENDS ${SRC_DIR}/../scripts/vk_generate.py ${SRC_DIR}/../../../xgl_helper.py @@ -75,10 +75,10 @@ set(UI_HEADER_LIST set(HDR_LIST glvdebug_xgl_settings.h glvdebug_xgl_qgroupframesproxymodel.h - codegen/glvtrace_xgl_packet_id.h - codegen/glvtrace_xgl_xgl_structs.h - codegen/glvtrace_xgl_xglwsix11ext_structs.h - codegen/glvtrace_xgl_xgldbg_structs.h + codegen/glv_vk_packet_id.h + codegen/glv_vk_vk_structs.h + codegen/glv_vk_vkwsix11ext_structs.h + codegen/glv_vk_vkdbg_structs.h ${SRC_DIR}/glvdebug/glvdebug_qgroupthreadsproxymodel.h ${SRC_DIR}/glvdebug/glvdebug_controller.h ${SRC_DIR}/glvreplay/glvreplay_factory.h diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h similarity index 99% rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h index d1dded3..d774f98 100644 --- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h +++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h @@ -29,9 +29,9 @@ #include "glv_trace_packet_utils.h" #include "glv_trace_packet_identifiers.h" #include "glv_interconnect.h" -#include "glvtrace_xgl_xgl_structs.h" -#include "glvtrace_xgl_xgldbg_structs.h" -#include "glvtrace_xgl_xglwsix11ext_structs.h" +#include "glv_vk_vk_structs.h" +#include "glv_vk_vkdbg_structs.h" +#include "glv_vk_vkwsix11ext_structs.h" #include "xgl_enum_string_helper.h" #if defined(WIN32) #define snprintf _snprintf diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vk_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl_structs.h rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vk_structs.h diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkdbg_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg_structs.h rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkdbg_structs.h diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkwsix11ext_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkwsix11ext_structs.h diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h index ef9fcd3..1322edf 100644 --- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h +++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h @@ -3,134 +3,154 @@ #include -static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) +static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) { - switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) + switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) { - case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC: - return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC"; - case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: - return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT"; + case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: + return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; default: - return "Unhandled XGL_DESCRIPTOR_REGION_USAGE"; + return "Unhandled XGL_PIPELINE_CREATE_FLAGS"; } } -static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) +static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) { - switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) + switch ((XGL_IMAGE_TILING)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_LINEAR_TILING: + return "XGL_LINEAR_TILING"; + case XGL_OPTIMAL_TILING: + return "XGL_OPTIMAL_TILING"; default: - return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS"; + return "Unhandled XGL_IMAGE_TILING"; } } -static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) +static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) { - switch ((XGL_MEMORY_TYPE)input_value) + switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)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_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_MEMORY_TYPE"; + return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS"; } } -static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) +static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) { - switch ((XGL_PIPELINE_SHADER_STAGE)input_value) + switch ((XGL_IMAGE_FORMAT_CLASS)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_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_PIPELINE_SHADER_STAGE"; + return "Unhandled XGL_IMAGE_FORMAT_CLASS"; } } -static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value) +static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value) { - switch ((XGL_CULL_MODE)input_value) + switch ((XGL_FORMAT_FEATURE_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_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_CULL_MODE"; + return "Unhandled XGL_FORMAT_FEATURE_FLAGS"; } } -static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) +static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value) { - switch ((XGL_IMAGE_LAYOUT)input_value) + switch ((XGL_IMAGE_VIEW_TYPE)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"; + 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_LAYOUT"; + return "Unhandled XGL_IMAGE_VIEW_TYPE"; } } -static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) +static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) { - switch ((XGL_MEMORY_PRIORITY)input_value) + switch ((XGL_PHYSICAL_GPU_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_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_MEMORY_PRIORITY"; + return "Unhandled XGL_PHYSICAL_GPU_TYPE"; } } @@ -149,52 +169,96 @@ static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) } -static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) +static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) { - switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) + switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) { - case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: - return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT"; + 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_SUBRESOURCE_INFO_TYPE"; + return "Unhandled XGL_SYSTEM_ALLOC_TYPE"; } } -static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) +static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) { - switch ((XGL_VALIDATION_LEVEL)input_value) + switch ((XGL_COMPARE_FUNC)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_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_VALIDATION_LEVEL"; + return "Unhandled XGL_COMPARE_FUNC"; } } -static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value) +static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value) { - switch ((XGL_STATE_BIND_POINT)input_value) + switch ((XGL_VERTEX_INPUT_STEP_RATE)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_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_STATE_BIND_POINT"; + return "Unhandled XGL_VERTEX_INPUT_STEP_RATE"; + } +} + + +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_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"; } } @@ -213,18 +277,54 @@ static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS } -static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) +static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) { - switch ((XGL_BORDER_COLOR_TYPE)input_value) + switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) { - case XGL_BORDER_COLOR_OPAQUE_BLACK: - return "XGL_BORDER_COLOR_OPAQUE_BLACK"; - case XGL_BORDER_COLOR_OPAQUE_WHITE: - return "XGL_BORDER_COLOR_OPAQUE_WHITE"; - case XGL_BORDER_COLOR_TRANSPARENT_BLACK: - return "XGL_BORDER_COLOR_TRANSPARENT_BLACK"; + case XGL_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_BORDER_COLOR_TYPE"; + return "Unhandled XGL_GPU_COMPATIBILITY_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_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"; } } @@ -245,6 +345,18 @@ static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input } +static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) +{ + switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) + { + case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: + return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT"; + default: + return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS"; + } +} + + static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) { switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value) @@ -263,259 +375,109 @@ static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INF } -static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value) +static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) { - switch ((XGL_FORMAT_FEATURE_FLAGS)input_value) + switch ((XGL_QUEUE_TYPE)input_value) { - case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT: - 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_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_FORMAT_FEATURE_FLAGS"; + return "Unhandled XGL_QUEUE_TYPE"; } } -static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) +static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value) { - switch ((XGL_QUERY_CONTROL_FLAGS)input_value) + switch ((XGL_DESCRIPTOR_SET_USAGE)input_value) { - case XGL_QUERY_IMPRECISE_DATA_BIT: - return "XGL_QUERY_IMPRECISE_DATA_BIT"; + 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_QUERY_CONTROL_FLAGS"; + return "Unhandled XGL_DESCRIPTOR_SET_USAGE"; } } -static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) +static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) { - switch ((XGL_IMAGE_CREATE_FLAGS)input_value) + switch ((XGL_COORDINATE_ORIGIN)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_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_CREATE_FLAGS"; + return "Unhandled XGL_COORDINATE_ORIGIN"; } } -static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value) +static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value) { - switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value) + switch ((XGL_FILL_MODE)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_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_VERTEX_INPUT_STEP_RATE"; + return "Unhandled XGL_FILL_MODE"; } } -static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) +static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) { - switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value) + switch ((XGL_WAIT_EVENT)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_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_PROPERTY_FLAGS"; + return "Unhandled XGL_WAIT_EVENT"; } } -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_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) +static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS 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_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_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_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_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_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value) -{ - switch ((XGL_BUFFER_USAGE_FLAGS)input_value) + switch ((XGL_BUFFER_USAGE_FLAGS)input_value) { case XGL_BUFFER_USAGE_GENERAL: return "XGL_BUFFER_USAGE_GENERAL"; @@ -551,272 +513,182 @@ static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS i } -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_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) +static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) { - switch ((XGL_QUEUE_FLAGS)input_value) + switch ((XGL_BLEND_FUNC)input_value) { - case XGL_QUEUE_COMPUTE_BIT: - return "XGL_QUEUE_COMPUTE_BIT"; - case XGL_QUEUE_DMA_BIT: - return "XGL_QUEUE_DMA_BIT"; - case XGL_QUEUE_EXTENDED_BIT: - return "XGL_QUEUE_EXTENDED_BIT"; - case XGL_QUEUE_GRAPHICS_BIT: - return "XGL_QUEUE_GRAPHICS_BIT"; + case XGL_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_QUEUE_FLAGS"; + return "Unhandled XGL_BLEND_FUNC"; } } -static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value) +static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value) { - switch ((XGL_IMAGE_VIEW_TYPE)input_value) + switch ((XGL_IMAGE_USAGE_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_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_VIEW_TYPE"; + return "Unhandled XGL_IMAGE_USAGE_FLAGS"; } } -static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) +static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) { - switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) + switch ((XGL_SHADER_STAGE_FLAGS)input_value) { - case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: - return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; + 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_PIPELINE_CREATE_FLAGS"; + return "Unhandled XGL_SHADER_STAGE_FLAGS"; } } -static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) +static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) { - switch ((XGL_MEMORY_REF_FLAGS)input_value) + switch ((XGL_TEX_MIPMAP_MODE)input_value) { - case XGL_MEMORY_REF_READ_ONLY_BIT: - return "XGL_MEMORY_REF_READ_ONLY_BIT"; + case XGL_TEX_MIPMAP_BASE: + return "XGL_TEX_MIPMAP_BASE"; + case XGL_TEX_MIPMAP_LINEAR: + return "XGL_TEX_MIPMAP_LINEAR"; + case XGL_TEX_MIPMAP_NEAREST: + return "XGL_TEX_MIPMAP_NEAREST"; default: - return "Unhandled XGL_MEMORY_REF_FLAGS"; + return "Unhandled XGL_TEX_MIPMAP_MODE"; } } -static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value) +static inline const char* string_XGL_RESULT(XGL_RESULT input_value) { - switch ((XGL_STRUCTURE_TYPE)input_value) + switch ((XGL_RESULT)input_value) { - case XGL_STRUCTURE_TYPE_APPLICATION_INFO: - return "XGL_STRUCTURE_TYPE_APPLICATION_INFO"; - case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: - return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"; - case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO: - return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO"; - case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO: - return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO"; - case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO: - return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO"; - case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO: - return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO"; - case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: - return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"; - case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO: - return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO"; - case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO: - return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO"; - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO: - return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO"; - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO: - return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO"; - case XGL_STRUCTURE_TYPE_MEMORY_BARRIER: - return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER"; - case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO: - return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO"; - case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO: - return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER: - return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER"; - case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO: - return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO"; - case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY: - return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY"; - case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS: - return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS"; - case XGL_STRUCTURE_TYPE_UPDATE_IMAGES: - return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES"; - case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS"; - case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES"; - default: - return "Unhandled XGL_STRUCTURE_TYPE"; - } -} - - -static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value) -{ - switch ((XGL_ATTACHMENT_STORE_OP)input_value) - { - case XGL_ATTACHMENT_STORE_OP_DONT_CARE: - return "XGL_ATTACHMENT_STORE_OP_DONT_CARE"; - case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA: - return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA"; - case XGL_ATTACHMENT_STORE_OP_STORE: - return "XGL_ATTACHMENT_STORE_OP_STORE"; - default: - return "Unhandled XGL_ATTACHMENT_STORE_OP"; - } -} - - -static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) -{ - switch ((XGL_WAIT_EVENT)input_value) - { - case XGL_WAIT_EVENT_BEFORE_RASTERIZATION: - return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION"; - case XGL_WAIT_EVENT_TOP_OF_PIPE: - return "XGL_WAIT_EVENT_TOP_OF_PIPE"; - default: - return "Unhandled XGL_WAIT_EVENT"; - } -} - - -static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) -{ - switch ((XGL_DEPTH_MODE)input_value) - { - case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: - return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE"; - case XGL_DEPTH_MODE_ZERO_TO_ONE: - return "XGL_DEPTH_MODE_ZERO_TO_ONE"; - default: - return "Unhandled XGL_DEPTH_MODE"; - } -} - - -static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value) -{ - switch ((XGL_FILL_MODE)input_value) - { - case XGL_FILL_POINTS: - return "XGL_FILL_POINTS"; - case XGL_FILL_SOLID: - return "XGL_FILL_SOLID"; - case XGL_FILL_WIREFRAME: - return "XGL_FILL_WIREFRAME"; - default: - return "Unhandled XGL_FILL_MODE"; - } -} - - -static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) -{ - switch ((XGL_TEX_MIPMAP_MODE)input_value) - { - case XGL_TEX_MIPMAP_BASE: - return "XGL_TEX_MIPMAP_BASE"; - case XGL_TEX_MIPMAP_LINEAR: - return "XGL_TEX_MIPMAP_LINEAR"; - case XGL_TEX_MIPMAP_NEAREST: - return "XGL_TEX_MIPMAP_NEAREST"; + 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_TEX_MIPMAP_MODE"; + return "Unhandled XGL_RESULT"; } } @@ -845,265 +717,211 @@ static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value) } -static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) +static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value) { - switch ((XGL_COORDINATE_ORIGIN)input_value) + switch ((XGL_STATE_BIND_POINT)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_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_COORDINATE_ORIGIN"; + return "Unhandled XGL_STATE_BIND_POINT"; } } -static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) +static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) { - switch ((XGL_IMAGE_ASPECT)input_value) + switch ((XGL_IMAGE_LAYOUT)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_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_ASPECT"; + return "Unhandled XGL_IMAGE_LAYOUT"; } } -static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) +static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) { - switch ((XGL_OBJECT_INFO_TYPE)input_value) + switch ((XGL_DESCRIPTOR_UPDATE_MODE)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_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_OBJECT_INFO_TYPE"; + return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE"; } } -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_INDEX_TYPE(XGL_INDEX_TYPE input_value) +static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value) { - switch ((XGL_INDEX_TYPE)input_value) + switch ((XGL_CULL_MODE)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_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_INDEX_TYPE"; + return "Unhandled XGL_CULL_MODE"; } } -static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) +static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) { - switch ((XGL_IMAGE_TILING)input_value) + switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) { - case XGL_LINEAR_TILING: - return "XGL_LINEAR_TILING"; - case XGL_OPTIMAL_TILING: - return "XGL_OPTIMAL_TILING"; + case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: + return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT"; default: - return "Unhandled XGL_IMAGE_TILING"; + return "Unhandled XGL_SUBRESOURCE_INFO_TYPE"; } } -static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) +static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) { - switch ((XGL_QUEUE_TYPE)input_value) + switch ((XGL_MEMORY_REF_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_MEMORY_REF_READ_ONLY_BIT: + return "XGL_MEMORY_REF_READ_ONLY_BIT"; default: - return "Unhandled XGL_QUEUE_TYPE"; + return "Unhandled XGL_MEMORY_REF_FLAGS"; } } -static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) +static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) { - switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) + switch ((XGL_QUERY_CONTROL_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_QUERY_IMPRECISE_DATA_BIT: + return "XGL_QUERY_IMPRECISE_DATA_BIT"; default: - return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS"; + return "Unhandled XGL_QUERY_CONTROL_FLAGS"; } } -static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) +static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) { - switch ((XGL_SHADER_STAGE_FLAGS)input_value) + switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value) { - case XGL_SHADER_STAGE_FLAGS_ALL: - return "XGL_SHADER_STAGE_FLAGS_ALL"; - case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT: - return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT"; - case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT: - return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT"; - case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT: - return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT"; - case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT: - return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT"; - case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT: - return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT"; - case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT: - return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT"; + case XGL_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_SHADER_STAGE_FLAGS"; + return "Unhandled XGL_MEMORY_PROPERTY_FLAGS"; } } -static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value) +static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) { - switch ((XGL_MEMORY_INPUT_FLAGS)input_value) + switch ((XGL_TIMESTAMP_TYPE)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_TIMESTAMP_BOTTOM: + return "XGL_TIMESTAMP_BOTTOM"; + case XGL_TIMESTAMP_TOP: + return "XGL_TIMESTAMP_TOP"; default: - return "Unhandled XGL_MEMORY_INPUT_FLAGS"; + 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_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) { - switch ((XGL_FORMAT_INFO_TYPE)input_value) + switch ((XGL_IMAGE_TYPE)input_value) { - case XGL_INFO_TYPE_FORMAT_PROPERTIES: - return "XGL_INFO_TYPE_FORMAT_PROPERTIES"; + 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_FORMAT_INFO_TYPE"; + return "Unhandled XGL_IMAGE_TYPE"; } } -static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) +static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) { - switch ((XGL_LOGIC_OP)input_value) + switch ((XGL_PIPELINE_SHADER_STAGE)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_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_LOGIC_OP"; + return "Unhandled XGL_PIPELINE_SHADER_STAGE"; } } -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_BLEND(XGL_BLEND input_value) +static inline const char* string_XGL_BLEND(XGL_BLEND input_value) { switch ((XGL_BLEND)input_value) { @@ -1151,50 +969,160 @@ static inline const char* string_XGL_BLEND(XGL_BLEND input_value) } -static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) +static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value) { - switch ((XGL_PHYSICAL_GPU_TYPE)input_value) + switch ((XGL_PRIMITIVE_TOPOLOGY)input_value) { - case XGL_GPU_TYPE_DISCRETE: - return "XGL_GPU_TYPE_DISCRETE"; - case XGL_GPU_TYPE_INTEGRATED: - return "XGL_GPU_TYPE_INTEGRATED"; - case XGL_GPU_TYPE_OTHER: - return "XGL_GPU_TYPE_OTHER"; - case XGL_GPU_TYPE_VIRTUAL: - return "XGL_GPU_TYPE_VIRTUAL"; + case XGL_TOPOLOGY_LINE_LIST: + return "XGL_TOPOLOGY_LINE_LIST"; + case XGL_TOPOLOGY_LINE_LIST_ADJ: + return "XGL_TOPOLOGY_LINE_LIST_ADJ"; + case XGL_TOPOLOGY_LINE_STRIP: + return "XGL_TOPOLOGY_LINE_STRIP"; + case XGL_TOPOLOGY_LINE_STRIP_ADJ: + return "XGL_TOPOLOGY_LINE_STRIP_ADJ"; + case XGL_TOPOLOGY_PATCH: + return "XGL_TOPOLOGY_PATCH"; + case XGL_TOPOLOGY_POINT_LIST: + return "XGL_TOPOLOGY_POINT_LIST"; + case XGL_TOPOLOGY_QUAD_LIST: + return "XGL_TOPOLOGY_QUAD_LIST"; + case XGL_TOPOLOGY_QUAD_STRIP: + return "XGL_TOPOLOGY_QUAD_STRIP"; + case XGL_TOPOLOGY_RECT_LIST: + return "XGL_TOPOLOGY_RECT_LIST"; + case XGL_TOPOLOGY_TRIANGLE_LIST: + return "XGL_TOPOLOGY_TRIANGLE_LIST"; + case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ: + return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ"; + case XGL_TOPOLOGY_TRIANGLE_STRIP: + return "XGL_TOPOLOGY_TRIANGLE_STRIP"; + case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ: + return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ"; default: - return "Unhandled XGL_PHYSICAL_GPU_TYPE"; + return "Unhandled XGL_PRIMITIVE_TOPOLOGY"; } } -static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value) +static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) { - switch ((XGL_IMAGE_USAGE_FLAGS)input_value) + switch ((XGL_VALIDATION_LEVEL)input_value) { - case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: - return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"; - case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT: - return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT"; - case XGL_IMAGE_USAGE_GENERAL: - return "XGL_IMAGE_USAGE_GENERAL"; - case XGL_IMAGE_USAGE_IMAGE_BIT: - return "XGL_IMAGE_USAGE_IMAGE_BIT"; - case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT: - return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT"; - case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT: - return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT"; - case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT: - return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT"; - case XGL_IMAGE_USAGE_TEXTURE_BIT: - return "XGL_IMAGE_USAGE_TEXTURE_BIT"; - case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT: - return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT"; - case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT: - return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT"; + case XGL_VALIDATION_LEVEL_0: + return "XGL_VALIDATION_LEVEL_0"; + case XGL_VALIDATION_LEVEL_1: + return "XGL_VALIDATION_LEVEL_1"; + case XGL_VALIDATION_LEVEL_2: + return "XGL_VALIDATION_LEVEL_2"; + case XGL_VALIDATION_LEVEL_3: + return "XGL_VALIDATION_LEVEL_3"; + case XGL_VALIDATION_LEVEL_4: + return "XGL_VALIDATION_LEVEL_4"; default: - return "Unhandled XGL_IMAGE_USAGE_FLAGS"; + return "Unhandled XGL_VALIDATION_LEVEL"; + } +} + + +static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) +{ + switch ((XGL_DESCRIPTOR_TYPE)input_value) + { + case XGL_DESCRIPTOR_TYPE_IMAGE: + return "XGL_DESCRIPTOR_TYPE_IMAGE"; + case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_RAW_BUFFER: + return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER"; + case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC"; + case XGL_DESCRIPTOR_TYPE_SAMPLER: + return "XGL_DESCRIPTOR_TYPE_SAMPLER"; + case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE: + return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE"; + case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC"; + case XGL_DESCRIPTOR_TYPE_TEXTURE: + return "XGL_DESCRIPTOR_TYPE_TEXTURE"; + case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER"; + case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"; + default: + return "Unhandled XGL_DESCRIPTOR_TYPE"; + } +} + + +static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value) +{ + switch ((XGL_ATTACHMENT_STORE_OP)input_value) + { + case XGL_ATTACHMENT_STORE_OP_DONT_CARE: + return "XGL_ATTACHMENT_STORE_OP_DONT_CARE"; + case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA: + return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA"; + case XGL_ATTACHMENT_STORE_OP_STORE: + return "XGL_ATTACHMENT_STORE_OP_STORE"; + default: + return "Unhandled XGL_ATTACHMENT_STORE_OP"; + } +} + + +static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) +{ + switch ((XGL_IMAGE_CREATE_FLAGS)input_value) + { + case XGL_IMAGE_CREATE_CLONEABLE_BIT: + return "XGL_IMAGE_CREATE_CLONEABLE_BIT"; + case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT: + return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT"; + case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT: + return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; + case XGL_IMAGE_CREATE_SHAREABLE_BIT: + return "XGL_IMAGE_CREATE_SHAREABLE_BIT"; + case XGL_IMAGE_CREATE_SPARSE_BIT: + return "XGL_IMAGE_CREATE_SPARSE_BIT"; + default: + return "Unhandled XGL_IMAGE_CREATE_FLAGS"; + } +} + + +static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) +{ + switch ((XGL_INDEX_TYPE)input_value) + { + case XGL_INDEX_16: + return "XGL_INDEX_16"; + case XGL_INDEX_32: + return "XGL_INDEX_32"; + case XGL_INDEX_8: + return "XGL_INDEX_8"; + default: + return "Unhandled XGL_INDEX_TYPE"; + } +} + + +static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) +{ + switch ((XGL_BORDER_COLOR_TYPE)input_value) + { + case XGL_BORDER_COLOR_OPAQUE_BLACK: + return "XGL_BORDER_COLOR_OPAQUE_BLACK"; + case XGL_BORDER_COLOR_OPAQUE_WHITE: + return "XGL_BORDER_COLOR_OPAQUE_WHITE"; + case XGL_BORDER_COLOR_TRANSPARENT_BLACK: + return "XGL_BORDER_COLOR_TRANSPARENT_BLACK"; + default: + return "Unhandled XGL_BORDER_COLOR_TYPE"; } } @@ -1543,340 +1471,412 @@ static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value) } -static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) +static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) { - switch ((XGL_TEX_FILTER)input_value) + switch ((XGL_TEX_ADDRESS)input_value) { - case XGL_TEX_FILTER_LINEAR: - return "XGL_TEX_FILTER_LINEAR"; - case XGL_TEX_FILTER_NEAREST: - return "XGL_TEX_FILTER_NEAREST"; + case XGL_TEX_ADDRESS_CLAMP: + return "XGL_TEX_ADDRESS_CLAMP"; + case XGL_TEX_ADDRESS_CLAMP_BORDER: + return "XGL_TEX_ADDRESS_CLAMP_BORDER"; + case XGL_TEX_ADDRESS_MIRROR: + return "XGL_TEX_ADDRESS_MIRROR"; + case XGL_TEX_ADDRESS_MIRROR_ONCE: + return "XGL_TEX_ADDRESS_MIRROR_ONCE"; + case XGL_TEX_ADDRESS_WRAP: + return "XGL_TEX_ADDRESS_WRAP"; default: - return "Unhandled XGL_TEX_FILTER"; + return "Unhandled XGL_TEX_ADDRESS"; } } -static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value) +static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) { - switch ((XGL_PRIMITIVE_TOPOLOGY)input_value) + switch ((XGL_DEPTH_MODE)input_value) { - case XGL_TOPOLOGY_LINE_LIST: - return "XGL_TOPOLOGY_LINE_LIST"; - case XGL_TOPOLOGY_LINE_LIST_ADJ: - return "XGL_TOPOLOGY_LINE_LIST_ADJ"; - case XGL_TOPOLOGY_LINE_STRIP: - return "XGL_TOPOLOGY_LINE_STRIP"; - case XGL_TOPOLOGY_LINE_STRIP_ADJ: - return "XGL_TOPOLOGY_LINE_STRIP_ADJ"; - case XGL_TOPOLOGY_PATCH: - return "XGL_TOPOLOGY_PATCH"; - case XGL_TOPOLOGY_POINT_LIST: - return "XGL_TOPOLOGY_POINT_LIST"; - case XGL_TOPOLOGY_QUAD_LIST: - return "XGL_TOPOLOGY_QUAD_LIST"; - case XGL_TOPOLOGY_QUAD_STRIP: - return "XGL_TOPOLOGY_QUAD_STRIP"; - case XGL_TOPOLOGY_RECT_LIST: - return "XGL_TOPOLOGY_RECT_LIST"; - case XGL_TOPOLOGY_TRIANGLE_LIST: - return "XGL_TOPOLOGY_TRIANGLE_LIST"; - case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ: - return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ"; - case XGL_TOPOLOGY_TRIANGLE_STRIP: - return "XGL_TOPOLOGY_TRIANGLE_STRIP"; - case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ: - return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ"; + case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: + return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE"; + case XGL_DEPTH_MODE_ZERO_TO_ONE: + return "XGL_DEPTH_MODE_ZERO_TO_ONE"; default: - return "Unhandled XGL_PRIMITIVE_TOPOLOGY"; + return "Unhandled XGL_DEPTH_MODE"; } } -static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) +static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) { - switch ((XGL_BLEND_FUNC)input_value) + switch ((XGL_MEMORY_PRIORITY)input_value) { - case XGL_BLEND_FUNC_ADD: - return "XGL_BLEND_FUNC_ADD"; - case XGL_BLEND_FUNC_MAX: - return "XGL_BLEND_FUNC_MAX"; - case XGL_BLEND_FUNC_MIN: - return "XGL_BLEND_FUNC_MIN"; - case XGL_BLEND_FUNC_REVERSE_SUBTRACT: - return "XGL_BLEND_FUNC_REVERSE_SUBTRACT"; - case XGL_BLEND_FUNC_SUBTRACT: - return "XGL_BLEND_FUNC_SUBTRACT"; + case XGL_MEMORY_PRIORITY_HIGH: + return "XGL_MEMORY_PRIORITY_HIGH"; + case XGL_MEMORY_PRIORITY_LOW: + return "XGL_MEMORY_PRIORITY_LOW"; + case XGL_MEMORY_PRIORITY_NORMAL: + return "XGL_MEMORY_PRIORITY_NORMAL"; + case XGL_MEMORY_PRIORITY_UNUSED: + return "XGL_MEMORY_PRIORITY_UNUSED"; + case XGL_MEMORY_PRIORITY_VERY_HIGH: + return "XGL_MEMORY_PRIORITY_VERY_HIGH"; + case XGL_MEMORY_PRIORITY_VERY_LOW: + return "XGL_MEMORY_PRIORITY_VERY_LOW"; default: - return "Unhandled XGL_BLEND_FUNC"; + return "Unhandled XGL_MEMORY_PRIORITY"; } } -static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) +static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value) { - switch ((XGL_FACE_ORIENTATION)input_value) + switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value) { - case XGL_FRONT_FACE_CCW: - return "XGL_FRONT_FACE_CCW"; - case XGL_FRONT_FACE_CW: - return "XGL_FRONT_FACE_CW"; + case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT: + return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT"; + case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT: + return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT"; + case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT: + return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT"; + case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT: + return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT"; default: - return "Unhandled XGL_FACE_ORIENTATION"; + return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS"; } } -static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) +static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) { - switch ((XGL_IMAGE_TYPE)input_value) + switch ((XGL_QUEUE_FLAGS)input_value) { - case XGL_IMAGE_1D: - return "XGL_IMAGE_1D"; - case XGL_IMAGE_2D: - return "XGL_IMAGE_2D"; - case XGL_IMAGE_3D: - return "XGL_IMAGE_3D"; + case XGL_QUEUE_COMPUTE_BIT: + return "XGL_QUEUE_COMPUTE_BIT"; + case XGL_QUEUE_DMA_BIT: + return "XGL_QUEUE_DMA_BIT"; + case XGL_QUEUE_EXTENDED_BIT: + return "XGL_QUEUE_EXTENDED_BIT"; + case XGL_QUEUE_GRAPHICS_BIT: + return "XGL_QUEUE_GRAPHICS_BIT"; default: - return "Unhandled XGL_IMAGE_TYPE"; + return "Unhandled XGL_QUEUE_FLAGS"; } } -static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) +static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value) { - switch ((XGL_IMAGE_FORMAT_CLASS)input_value) + switch ((XGL_MEMORY_INPUT_FLAGS)input_value) { - case XGL_IMAGE_FORMAT_CLASS_128_BITS: - return "XGL_IMAGE_FORMAT_CLASS_128_BITS"; - case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK: - return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK"; - case XGL_IMAGE_FORMAT_CLASS_16_BITS: - return "XGL_IMAGE_FORMAT_CLASS_16_BITS"; - case XGL_IMAGE_FORMAT_CLASS_24_BITS: - return "XGL_IMAGE_FORMAT_CLASS_24_BITS"; - case XGL_IMAGE_FORMAT_CLASS_32_BITS: - return "XGL_IMAGE_FORMAT_CLASS_32_BITS"; - case XGL_IMAGE_FORMAT_CLASS_48_BITS: - return "XGL_IMAGE_FORMAT_CLASS_48_BITS"; - case XGL_IMAGE_FORMAT_CLASS_64_BITS: - return "XGL_IMAGE_FORMAT_CLASS_64_BITS"; - case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK: - return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK"; - case XGL_IMAGE_FORMAT_CLASS_8_BITS: - return "XGL_IMAGE_FORMAT_CLASS_8_BITS"; - case XGL_IMAGE_FORMAT_CLASS_96_BITS: - return "XGL_IMAGE_FORMAT_CLASS_96_BITS"; - case XGL_IMAGE_FORMAT_CLASS_D16: - return "XGL_IMAGE_FORMAT_CLASS_D16"; - case XGL_IMAGE_FORMAT_CLASS_D16S8: - return "XGL_IMAGE_FORMAT_CLASS_D16S8"; - case XGL_IMAGE_FORMAT_CLASS_D24: - return "XGL_IMAGE_FORMAT_CLASS_D24"; - case XGL_IMAGE_FORMAT_CLASS_D24S8: - return "XGL_IMAGE_FORMAT_CLASS_D24S8"; - case XGL_IMAGE_FORMAT_CLASS_D32: - return "XGL_IMAGE_FORMAT_CLASS_D32"; - case XGL_IMAGE_FORMAT_CLASS_D32S8: - return "XGL_IMAGE_FORMAT_CLASS_D32S8"; - case XGL_IMAGE_FORMAT_CLASS_LINEAR: - return "XGL_IMAGE_FORMAT_CLASS_LINEAR"; - case XGL_IMAGE_FORMAT_CLASS_S8: - return "XGL_IMAGE_FORMAT_CLASS_S8"; + case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT: + return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT"; + case XGL_MEMORY_INPUT_COPY_BIT: + return "XGL_MEMORY_INPUT_COPY_BIT"; + case XGL_MEMORY_INPUT_CPU_READ_BIT: + return "XGL_MEMORY_INPUT_CPU_READ_BIT"; + case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT: + return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT"; + case XGL_MEMORY_INPUT_INDEX_FETCH_BIT: + return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT"; + case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT: + return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT"; + case XGL_MEMORY_INPUT_SHADER_READ_BIT: + return "XGL_MEMORY_INPUT_SHADER_READ_BIT"; + case XGL_MEMORY_INPUT_UNIFORM_READ_BIT: + return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT"; + case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT: + return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT"; + default: + return "Unhandled XGL_MEMORY_INPUT_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_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_IMAGE_FORMAT_CLASS"; + return "Unhandled XGL_STRUCTURE_TYPE"; } } -static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) +static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) { - switch ((XGL_ATTACHMENT_LOAD_OP)input_value) + switch ((XGL_MEMORY_OUTPUT_FLAGS)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_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_ATTACHMENT_LOAD_OP"; + return "Unhandled XGL_MEMORY_OUTPUT_FLAGS"; } } -static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) +static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) { - switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value) + switch ((XGL_LOGIC_OP)input_value) { - case XGL_PROVOKING_VERTEX_FIRST: - return "XGL_PROVOKING_VERTEX_FIRST"; - case XGL_PROVOKING_VERTEX_LAST: - return "XGL_PROVOKING_VERTEX_LAST"; + 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_PROVOKING_VERTEX_CONVENTION"; + return "Unhandled XGL_LOGIC_OP"; } } -static inline const char* string_XGL_RESULT(XGL_RESULT input_value) +static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) { - switch ((XGL_RESULT)input_value) + switch ((XGL_FORMAT_INFO_TYPE)input_value) { - case XGL_ERROR_BAD_PIPELINE_DATA: - return "XGL_ERROR_BAD_PIPELINE_DATA"; - case XGL_ERROR_BAD_SHADER_CODE: - return "XGL_ERROR_BAD_SHADER_CODE"; - case XGL_ERROR_BUILDING_COMMAND_BUFFER: - return "XGL_ERROR_BUILDING_COMMAND_BUFFER"; - case XGL_ERROR_DEVICE_ALREADY_CREATED: - return "XGL_ERROR_DEVICE_ALREADY_CREATED"; - case XGL_ERROR_DEVICE_LOST: - return "XGL_ERROR_DEVICE_LOST"; - case XGL_ERROR_INCOMPATIBLE_DEVICE: - return "XGL_ERROR_INCOMPATIBLE_DEVICE"; - case XGL_ERROR_INCOMPATIBLE_DRIVER: - return "XGL_ERROR_INCOMPATIBLE_DRIVER"; - case XGL_ERROR_INCOMPATIBLE_QUEUE: - return "XGL_ERROR_INCOMPATIBLE_QUEUE"; - case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER: - return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER"; - case XGL_ERROR_INITIALIZATION_FAILED: - return "XGL_ERROR_INITIALIZATION_FAILED"; - case XGL_ERROR_INVALID_ALIGNMENT: - return "XGL_ERROR_INVALID_ALIGNMENT"; - case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA: - return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA"; - case XGL_ERROR_INVALID_EXTENSION: - return "XGL_ERROR_INVALID_EXTENSION"; - case XGL_ERROR_INVALID_FLAGS: - return "XGL_ERROR_INVALID_FLAGS"; - case XGL_ERROR_INVALID_FORMAT: - return "XGL_ERROR_INVALID_FORMAT"; - case XGL_ERROR_INVALID_HANDLE: - return "XGL_ERROR_INVALID_HANDLE"; - case XGL_ERROR_INVALID_IMAGE: - return "XGL_ERROR_INVALID_IMAGE"; - case XGL_ERROR_INVALID_MEMORY_SIZE: - return "XGL_ERROR_INVALID_MEMORY_SIZE"; - case XGL_ERROR_INVALID_OBJECT_TYPE: - return "XGL_ERROR_INVALID_OBJECT_TYPE"; - case XGL_ERROR_INVALID_ORDINAL: - return "XGL_ERROR_INVALID_ORDINAL"; - case XGL_ERROR_INVALID_POINTER: - return "XGL_ERROR_INVALID_POINTER"; - case XGL_ERROR_INVALID_QUEUE_TYPE: - return "XGL_ERROR_INVALID_QUEUE_TYPE"; - case XGL_ERROR_INVALID_VALUE: - return "XGL_ERROR_INVALID_VALUE"; - case XGL_ERROR_MEMORY_MAP_FAILED: - return "XGL_ERROR_MEMORY_MAP_FAILED"; - case XGL_ERROR_MEMORY_NOT_BOUND: - return "XGL_ERROR_MEMORY_NOT_BOUND"; - case XGL_ERROR_MEMORY_UNMAP_FAILED: - return "XGL_ERROR_MEMORY_UNMAP_FAILED"; - case XGL_ERROR_NOT_MAPPABLE: - return "XGL_ERROR_NOT_MAPPABLE"; - case XGL_ERROR_NOT_SHAREABLE: - return "XGL_ERROR_NOT_SHAREABLE"; - case XGL_ERROR_OUT_OF_GPU_MEMORY: - return "XGL_ERROR_OUT_OF_GPU_MEMORY"; - case XGL_ERROR_OUT_OF_MEMORY: - return "XGL_ERROR_OUT_OF_MEMORY"; - case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES: - return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES"; - case XGL_ERROR_UNAVAILABLE: - return "XGL_ERROR_UNAVAILABLE"; - case XGL_ERROR_UNKNOWN: - return "XGL_ERROR_UNKNOWN"; - case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION: - return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION"; - case XGL_EVENT_RESET: - return "XGL_EVENT_RESET"; - case XGL_EVENT_SET: - return "XGL_EVENT_SET"; - case XGL_NOT_READY: - return "XGL_NOT_READY"; - case XGL_SUCCESS: - return "XGL_SUCCESS"; - case XGL_TIMEOUT: - return "XGL_TIMEOUT"; - case XGL_UNSUPPORTED: - return "XGL_UNSUPPORTED"; + case XGL_INFO_TYPE_FORMAT_PROPERTIES: + return "XGL_INFO_TYPE_FORMAT_PROPERTIES"; default: - return "Unhandled XGL_RESULT"; + return "Unhandled XGL_FORMAT_INFO_TYPE"; } } -static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) +static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) { - switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) + switch ((XGL_CHANNEL_SWIZZLE)input_value) { - case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: - return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT"; + 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_SEMAPHORE_CREATE_FLAGS"; + return "Unhandled XGL_CHANNEL_SWIZZLE"; } } -static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) +static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) { - switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) + switch ((XGL_PIPELINE_BIND_POINT)input_value) { - case XGL_SYSTEM_ALLOC_API_OBJECT: - return "XGL_SYSTEM_ALLOC_API_OBJECT"; - case XGL_SYSTEM_ALLOC_DEBUG: - return "XGL_SYSTEM_ALLOC_DEBUG"; - case XGL_SYSTEM_ALLOC_INTERNAL: - return "XGL_SYSTEM_ALLOC_INTERNAL"; - case XGL_SYSTEM_ALLOC_INTERNAL_SHADER: - return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER"; - case XGL_SYSTEM_ALLOC_INTERNAL_TEMP: - return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP"; + case XGL_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_SYSTEM_ALLOC_TYPE"; + return "Unhandled XGL_PIPELINE_BIND_POINT"; } } -static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) +static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) { - switch ((XGL_STENCIL_OP)input_value) + switch ((XGL_PROVOKING_VERTEX_CONVENTION)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_PROVOKING_VERTEX_FIRST: + return "XGL_PROVOKING_VERTEX_FIRST"; + case XGL_PROVOKING_VERTEX_LAST: + return "XGL_PROVOKING_VERTEX_LAST"; default: - return "Unhandled XGL_STENCIL_OP"; + return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION"; } } -static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) +static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) { - switch ((XGL_TIMESTAMP_TYPE)input_value) + switch ((XGL_OBJECT_INFO_TYPE)input_value) { - case XGL_TIMESTAMP_BOTTOM: - return "XGL_TIMESTAMP_BOTTOM"; - case XGL_TIMESTAMP_TOP: - return "XGL_TIMESTAMP_TOP"; + 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_TIMESTAMP_TYPE"; + return "Unhandled XGL_OBJECT_INFO_TYPE"; + } +} + + +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"; } } diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h index d9fa7e4..36d35e6 100644 --- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h +++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h @@ -3,12 +3,11 @@ #include -static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) +static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) { - switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) + switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) { - case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC: - case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: + case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: return 1; default: return 0; @@ -16,12 +15,12 @@ static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGIO } -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_TILING(XGL_IMAGE_TILING input_value) { - switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) + switch ((XGL_IMAGE_TILING)input_value) { - case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT: - case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT: + case XGL_LINEAR_TILING: + case XGL_OPTIMAL_TILING: return 1; default: return 0; @@ -29,13 +28,12 @@ static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_ST } -static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) +static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) { - switch ((XGL_MEMORY_TYPE)input_value) + switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) { - case XGL_MEMORY_TYPE_BUFFER: - case XGL_MEMORY_TYPE_IMAGE: - case XGL_MEMORY_TYPE_OTHER: + 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; @@ -43,16 +41,28 @@ static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) } -static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) +static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) { - switch ((XGL_PIPELINE_SHADER_STAGE)input_value) + switch ((XGL_IMAGE_FORMAT_CLASS)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_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; @@ -60,14 +70,20 @@ static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_ST } -static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value) +static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value) { - switch ((XGL_CULL_MODE)input_value) + switch ((XGL_FORMAT_FEATURE_FLAGS)input_value) { - case XGL_CULL_BACK: - case XGL_CULL_FRONT: - case XGL_CULL_FRONT_AND_BACK: - case XGL_CULL_NONE: + 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; @@ -75,18 +91,14 @@ static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value) } -static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) +static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value) { - switch ((XGL_IMAGE_LAYOUT)input_value) + switch ((XGL_IMAGE_VIEW_TYPE)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_IMAGE_VIEW_1D: + case XGL_IMAGE_VIEW_2D: + case XGL_IMAGE_VIEW_3D: + case XGL_IMAGE_VIEW_CUBE: return 1; default: return 0; @@ -94,16 +106,14 @@ static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) } -static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) +static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) { - switch ((XGL_MEMORY_PRIORITY)input_value) + switch ((XGL_PHYSICAL_GPU_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_GPU_TYPE_DISCRETE: + case XGL_GPU_TYPE_INTEGRATED: + case XGL_GPU_TYPE_OTHER: + case XGL_GPU_TYPE_VIRTUAL: return 1; default: return 0; @@ -124,11 +134,15 @@ static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) } -static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) +static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) { - switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) + switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) { - case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: + 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; @@ -136,15 +150,18 @@ static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_T } -static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) +static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) { - switch ((XGL_VALIDATION_LEVEL)input_value) + switch ((XGL_COMPARE_FUNC)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_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; @@ -152,14 +169,13 @@ static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_ } -static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value) +static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value) { - switch ((XGL_STATE_BIND_POINT)input_value) + switch ((XGL_VERTEX_INPUT_STEP_RATE)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_VERTEX_INPUT_STEP_RATE_DRAW: + case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE: + case XGL_VERTEX_INPUT_STEP_RATE_VERTEX: return 1; default: return 0; @@ -167,12 +183,13 @@ static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_ } -static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) { - switch ((XGL_BUFFER_CREATE_FLAGS)input_value) + switch ((XGL_ATTACHMENT_LOAD_OP)input_value) { - case XGL_BUFFER_CREATE_SHAREABLE_BIT: - case XGL_BUFFER_CREATE_SPARSE_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; @@ -180,13 +197,13 @@ static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS } -static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) +static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) { - switch ((XGL_BORDER_COLOR_TYPE)input_value) + switch ((XGL_IMAGE_ASPECT)input_value) { - case XGL_BORDER_COLOR_OPAQUE_BLACK: - case XGL_BORDER_COLOR_OPAQUE_WHITE: - case XGL_BORDER_COLOR_TRANSPARENT_BLACK: + case XGL_IMAGE_ASPECT_COLOR: + case XGL_IMAGE_ASPECT_DEPTH: + case XGL_IMAGE_ASPECT_STENCIL: return 1; default: return 0; @@ -194,13 +211,12 @@ static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE inpu } -static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value) +static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) { - switch ((XGL_BUFFER_VIEW_TYPE)input_value) + switch ((XGL_BUFFER_CREATE_FLAGS)input_value) { - case XGL_BUFFER_VIEW_RAW: - case XGL_BUFFER_VIEW_STRUCTURED: - case XGL_BUFFER_VIEW_TYPED: + case XGL_BUFFER_CREATE_SHAREABLE_BIT: + case XGL_BUFFER_CREATE_SPARSE_BIT: return 1; default: return 0; @@ -208,14 +224,17 @@ static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_ } -static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) +static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) { - switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value) + switch ((XGL_GPU_COMPATIBILITY_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_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; @@ -223,20 +242,12 @@ static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO } -static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value) +static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) { - switch ((XGL_FORMAT_FEATURE_FLAGS)input_value) + switch ((XGL_FACE_ORIENTATION)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_FRONT_FACE_CCW: + case XGL_FRONT_FACE_CW: return 1; default: return 0; @@ -244,11 +255,12 @@ static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAG } -static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) +static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) { - switch ((XGL_QUERY_CONTROL_FLAGS)input_value) + switch ((XGL_TEX_FILTER)input_value) { - case XGL_QUERY_IMPRECISE_DATA_BIT: + case XGL_TEX_FILTER_LINEAR: + case XGL_TEX_FILTER_NEAREST: return 1; default: return 0; @@ -256,15 +268,13 @@ static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS } -static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value) { - switch ((XGL_IMAGE_CREATE_FLAGS)input_value) + switch ((XGL_BUFFER_VIEW_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_BUFFER_VIEW_RAW: + case XGL_BUFFER_VIEW_STRUCTURED: + case XGL_BUFFER_VIEW_TYPED: return 1; default: return 0; @@ -272,13 +282,11 @@ static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS in } -static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value) +static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) { - switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value) + switch ((XGL_SEMAPHORE_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_SEMAPHORE_CREATE_SHAREABLE_BIT: return 1; default: return 0; @@ -286,17 +294,14 @@ static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP } -static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) +static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) { - switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value) + switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value) { - case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT: - case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT: - case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT: - case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT: - case XGL_MEMORY_PROPERTY_GPU_ONLY: - case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL: - case XGL_MEMORY_PROPERTY_SHAREABLE_BIT: + case XGL_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; @@ -304,18 +309,13 @@ static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FL } -static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) +static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) { - switch ((XGL_COMPARE_FUNC)input_value) + switch ((XGL_QUEUE_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_QUEUE_TYPE_COMPUTE: + case XGL_QUEUE_TYPE_DMA: + case XGL_QUEUE_TYPE_GRAPHICS: return 1; default: return 0; @@ -323,27 +323,12 @@ static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) } -static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value) { - switch ((XGL_PIPELINE_BIND_POINT)input_value) - { - case XGL_PIPELINE_BIND_POINT_COMPUTE: - case XGL_PIPELINE_BIND_POINT_GRAPHICS: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value) -{ - switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value) + switch ((XGL_DESCRIPTOR_SET_USAGE)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_DESCRIPTOR_SET_USAGE_ONE_SHOT: + case XGL_DESCRIPTOR_SET_USAGE_STATIC: return 1; default: return 0; @@ -351,22 +336,12 @@ static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_ } -static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) +static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) { - switch ((XGL_DESCRIPTOR_TYPE)input_value) + switch ((XGL_COORDINATE_ORIGIN)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_COORDINATE_ORIGIN_LOWER_LEFT: + case XGL_COORDINATE_ORIGIN_UPPER_LEFT: return 1; default: return 0; @@ -374,12 +349,13 @@ static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_va } -static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) +static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value) { - switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value) + switch ((XGL_FILL_MODE)input_value) { - case XGL_DESCRIPTOR_UDPATE_MODE_COPY: - case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST: + case XGL_FILL_POINTS: + case XGL_FILL_SOLID: + case XGL_FILL_WIREFRAME: return 1; default: return 0; @@ -387,16 +363,12 @@ static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE } -static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) +static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) { - switch ((XGL_CHANNEL_SWIZZLE)input_value) + switch ((XGL_WAIT_EVENT)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_WAIT_EVENT_BEFORE_RASTERIZATION: + case XGL_WAIT_EVENT_TOP_OF_PIPE: return 1; default: return 0; @@ -404,15 +376,18 @@ static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_va } -static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) +static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) { - switch ((XGL_TEX_ADDRESS)input_value) + switch ((XGL_STENCIL_OP)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_STENCIL_OP_DEC_CLAMP: + case XGL_STENCIL_OP_DEC_WRAP: + case XGL_STENCIL_OP_INC_CLAMP: + case XGL_STENCIL_OP_INC_WRAP: + case XGL_STENCIL_OP_INVERT: + case XGL_STENCIL_OP_KEEP: + case XGL_STENCIL_OP_REPLACE: + case XGL_STENCIL_OP_ZERO: return 1; default: return 0; @@ -445,12 +420,15 @@ static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS in } -static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) { - switch ((XGL_DEVICE_CREATE_FLAGS)input_value) + switch ((XGL_BLEND_FUNC)input_value) { - case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT: - case XGL_DEVICE_CREATE_VALIDATION_BIT: + case XGL_BLEND_FUNC_ADD: + case XGL_BLEND_FUNC_MAX: + case XGL_BLEND_FUNC_MIN: + case XGL_BLEND_FUNC_REVERSE_SUBTRACT: + case XGL_BLEND_FUNC_SUBTRACT: return 1; default: return 0; @@ -458,14 +436,20 @@ static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS } -static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) +static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value) { - switch ((XGL_QUEUE_FLAGS)input_value) + switch ((XGL_IMAGE_USAGE_FLAGS)input_value) { - case XGL_QUEUE_COMPUTE_BIT: - case XGL_QUEUE_DMA_BIT: - case XGL_QUEUE_EXTENDED_BIT: - case XGL_QUEUE_GRAPHICS_BIT: + 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; @@ -473,14 +457,17 @@ static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) } -static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value) +static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) { - switch ((XGL_IMAGE_VIEW_TYPE)input_value) + switch ((XGL_SHADER_STAGE_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_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; @@ -488,11 +475,13 @@ static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_va } -static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) { - switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) + switch ((XGL_TEX_MIPMAP_MODE)input_value) { - case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: + case XGL_TEX_MIPMAP_BASE: + case XGL_TEX_MIPMAP_LINEAR: + case XGL_TEX_MIPMAP_NEAREST: return 1; default: return 0; @@ -500,11 +489,50 @@ static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FL } -static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) +static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value) { - switch ((XGL_MEMORY_REF_FLAGS)input_value) + switch ((XGL_RESULT)input_value) { - case XGL_MEMORY_REF_READ_ONLY_BIT: + 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; @@ -512,65 +540,17 @@ static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_ } -static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value) +static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value) { - switch ((XGL_STRUCTURE_TYPE)input_value) + switch ((XGL_SET_EVENT)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_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; @@ -578,13 +558,14 @@ static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_valu } -static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value) +static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value) { - switch ((XGL_ATTACHMENT_STORE_OP)input_value) + switch ((XGL_STATE_BIND_POINT)input_value) { - case XGL_ATTACHMENT_STORE_OP_DONT_CARE: - case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA: - case XGL_ATTACHMENT_STORE_OP_STORE: + 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; @@ -592,12 +573,18 @@ static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP } -static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) +static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) { - switch ((XGL_WAIT_EVENT)input_value) + switch ((XGL_IMAGE_LAYOUT)input_value) { - case XGL_WAIT_EVENT_BEFORE_RASTERIZATION: - case XGL_WAIT_EVENT_TOP_OF_PIPE: + 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; @@ -605,12 +592,12 @@ static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) } -static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) { - switch ((XGL_DEPTH_MODE)input_value) + switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value) { - case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: - case XGL_DEPTH_MODE_ZERO_TO_ONE: + case XGL_DESCRIPTOR_UDPATE_MODE_COPY: + case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST: return 1; default: return 0; @@ -618,13 +605,13 @@ static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) } -static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value) +static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) { - switch ((XGL_FILL_MODE)input_value) + switch ((XGL_MEMORY_TYPE)input_value) { - case XGL_FILL_POINTS: - case XGL_FILL_SOLID: - case XGL_FILL_WIREFRAME: + case XGL_MEMORY_TYPE_BUFFER: + case XGL_MEMORY_TYPE_IMAGE: + case XGL_MEMORY_TYPE_OTHER: return 1; default: return 0; @@ -632,13 +619,14 @@ static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value) } -static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) +static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value) { - switch ((XGL_TEX_MIPMAP_MODE)input_value) + switch ((XGL_CULL_MODE)input_value) { - case XGL_TEX_MIPMAP_BASE: - case XGL_TEX_MIPMAP_LINEAR: - case XGL_TEX_MIPMAP_NEAREST: + case XGL_CULL_BACK: + case XGL_CULL_FRONT: + case XGL_CULL_FRONT_AND_BACK: + case XGL_CULL_NONE: return 1; default: return 0; @@ -646,17 +634,11 @@ static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_va } -static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value) +static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) { - switch ((XGL_SET_EVENT)input_value) + switch ((XGL_SUBRESOURCE_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_SUBRESOURCE_LAYOUT: return 1; default: return 0; @@ -664,12 +646,11 @@ static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value) } -static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) +static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) { - switch ((XGL_COORDINATE_ORIGIN)input_value) + switch ((XGL_MEMORY_REF_FLAGS)input_value) { - case XGL_COORDINATE_ORIGIN_LOWER_LEFT: - case XGL_COORDINATE_ORIGIN_UPPER_LEFT: + case XGL_MEMORY_REF_READ_ONLY_BIT: return 1; default: return 0; @@ -677,13 +658,11 @@ static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN inpu } -static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) +static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) { - switch ((XGL_IMAGE_ASPECT)input_value) + switch ((XGL_QUERY_CONTROL_FLAGS)input_value) { - case XGL_IMAGE_ASPECT_COLOR: - case XGL_IMAGE_ASPECT_DEPTH: - case XGL_IMAGE_ASPECT_STENCIL: + case XGL_QUERY_IMPRECISE_DATA_BIT: return 1; default: return 0; @@ -691,14 +670,17 @@ static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) } -static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) +static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) { - switch ((XGL_OBJECT_INFO_TYPE)input_value) + switch ((XGL_MEMORY_PROPERTY_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_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; @@ -706,12 +688,12 @@ static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_ } -static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value) +static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) { - switch ((XGL_DESCRIPTOR_SET_USAGE)input_value) + switch ((XGL_TIMESTAMP_TYPE)input_value) { - case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT: - case XGL_DESCRIPTOR_SET_USAGE_STATIC: + case XGL_TIMESTAMP_BOTTOM: + case XGL_TIMESTAMP_TOP: return 1; default: return 0; @@ -719,13 +701,13 @@ static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAG } -static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) +static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) { - switch ((XGL_INDEX_TYPE)input_value) + switch ((XGL_IMAGE_TYPE)input_value) { - case XGL_INDEX_16: - case XGL_INDEX_32: - case XGL_INDEX_8: + case XGL_IMAGE_1D: + case XGL_IMAGE_2D: + case XGL_IMAGE_3D: return 1; default: return 0; @@ -733,12 +715,16 @@ static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) } -static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) +static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) { - switch ((XGL_IMAGE_TILING)input_value) + switch ((XGL_PIPELINE_SHADER_STAGE)input_value) { - case XGL_LINEAR_TILING: - case XGL_OPTIMAL_TILING: + 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; @@ -746,13 +732,29 @@ static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) } -static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) +static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value) { - switch ((XGL_QUEUE_TYPE)input_value) + switch ((XGL_BLEND)input_value) { - case XGL_QUEUE_TYPE_COMPUTE: - case XGL_QUEUE_TYPE_DMA: - case XGL_QUEUE_TYPE_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; @@ -760,17 +762,23 @@ static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) } -static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) +static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value) { - switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) + switch ((XGL_PRIMITIVE_TOPOLOGY)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_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; @@ -778,17 +786,15 @@ static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILIT } -static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) +static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) { - switch ((XGL_SHADER_STAGE_FLAGS)input_value) + switch ((XGL_VALIDATION_LEVEL)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_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; @@ -796,19 +802,22 @@ static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS in } -static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) { - switch ((XGL_MEMORY_INPUT_FLAGS)input_value) + switch ((XGL_DESCRIPTOR_TYPE)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_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; @@ -816,11 +825,13 @@ static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS in } -static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) +static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value) { - switch ((XGL_FORMAT_INFO_TYPE)input_value) + switch ((XGL_ATTACHMENT_STORE_OP)input_value) { - case XGL_INFO_TYPE_FORMAT_PROPERTIES: + 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; @@ -828,26 +839,15 @@ static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_ } -static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) +static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) { - switch ((XGL_LOGIC_OP)input_value) + switch ((XGL_IMAGE_CREATE_FLAGS)input_value) { - case XGL_LOGIC_OP_AND: - case XGL_LOGIC_OP_AND_INVERTED: - case XGL_LOGIC_OP_AND_REVERSE: - case XGL_LOGIC_OP_CLEAR: - case XGL_LOGIC_OP_COPY: - case XGL_LOGIC_OP_COPY_INVERTED: - case XGL_LOGIC_OP_EQUIV: - case XGL_LOGIC_OP_INVERT: - case XGL_LOGIC_OP_NAND: - case XGL_LOGIC_OP_NOOP: - case XGL_LOGIC_OP_NOR: - case XGL_LOGIC_OP_OR: - case XGL_LOGIC_OP_OR_INVERTED: - case XGL_LOGIC_OP_OR_REVERSE: - case XGL_LOGIC_OP_SET: - case XGL_LOGIC_OP_XOR: + case XGL_IMAGE_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; @@ -855,15 +855,13 @@ static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) } -static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) +static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) { - switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value) + switch ((XGL_INDEX_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_INDEX_16: + case XGL_INDEX_32: + case XGL_INDEX_8: return 1; default: return 0; @@ -871,65 +869,13 @@ static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS } -static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value) +static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) { - switch ((XGL_BLEND)input_value) + switch ((XGL_BORDER_COLOR_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: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) -{ - switch ((XGL_PHYSICAL_GPU_TYPE)input_value) - { - case XGL_GPU_TYPE_DISCRETE: - case XGL_GPU_TYPE_INTEGRATED: - case XGL_GPU_TYPE_OTHER: - case XGL_GPU_TYPE_VIRTUAL: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_IMAGE_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: + case XGL_BORDER_COLOR_OPAQUE_BLACK: + case XGL_BORDER_COLOR_OPAQUE_WHITE: + case XGL_BORDER_COLOR_TRANSPARENT_BLACK: return 1; default: return 0; @@ -1115,12 +1061,15 @@ static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value) } -static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) +static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) { - switch ((XGL_TEX_FILTER)input_value) + switch ((XGL_TEX_ADDRESS)input_value) { - case XGL_TEX_FILTER_LINEAR: - case XGL_TEX_FILTER_NEAREST: + case XGL_TEX_ADDRESS_CLAMP: + case XGL_TEX_ADDRESS_CLAMP_BORDER: + case XGL_TEX_ADDRESS_MIRROR: + case XGL_TEX_ADDRESS_MIRROR_ONCE: + case XGL_TEX_ADDRESS_WRAP: return 1; default: return 0; @@ -1128,23 +1077,12 @@ static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) } -static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value) +static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) { - switch ((XGL_PRIMITIVE_TOPOLOGY)input_value) + switch ((XGL_DEPTH_MODE)input_value) { - case XGL_TOPOLOGY_LINE_LIST: - case XGL_TOPOLOGY_LINE_LIST_ADJ: - case XGL_TOPOLOGY_LINE_STRIP: - case XGL_TOPOLOGY_LINE_STRIP_ADJ: - case XGL_TOPOLOGY_PATCH: - case XGL_TOPOLOGY_POINT_LIST: - case XGL_TOPOLOGY_QUAD_LIST: - case XGL_TOPOLOGY_QUAD_STRIP: - case XGL_TOPOLOGY_RECT_LIST: - case XGL_TOPOLOGY_TRIANGLE_LIST: - case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ: - case XGL_TOPOLOGY_TRIANGLE_STRIP: - case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ: + case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: + case XGL_DEPTH_MODE_ZERO_TO_ONE: return 1; default: return 0; @@ -1152,15 +1090,16 @@ static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY in } -static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) +static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) { - switch ((XGL_BLEND_FUNC)input_value) + switch ((XGL_MEMORY_PRIORITY)input_value) { - case XGL_BLEND_FUNC_ADD: - case XGL_BLEND_FUNC_MAX: - case XGL_BLEND_FUNC_MIN: - case XGL_BLEND_FUNC_REVERSE_SUBTRACT: - case XGL_BLEND_FUNC_SUBTRACT: + case XGL_MEMORY_PRIORITY_HIGH: + case XGL_MEMORY_PRIORITY_LOW: + case XGL_MEMORY_PRIORITY_NORMAL: + case XGL_MEMORY_PRIORITY_UNUSED: + case XGL_MEMORY_PRIORITY_VERY_HIGH: + case XGL_MEMORY_PRIORITY_VERY_LOW: return 1; default: return 0; @@ -1168,12 +1107,14 @@ static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) } -static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) +static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value) { - switch ((XGL_FACE_ORIENTATION)input_value) + switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value) { - case XGL_FRONT_FACE_CCW: - case XGL_FRONT_FACE_CW: + case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT: + case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT: + case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT: + case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT: return 1; default: return 0; @@ -1181,13 +1122,14 @@ static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_ } -static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) +static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) { - switch ((XGL_IMAGE_TYPE)input_value) + switch ((XGL_QUEUE_FLAGS)input_value) { - case XGL_IMAGE_1D: - case XGL_IMAGE_2D: - case XGL_IMAGE_3D: + case XGL_QUEUE_COMPUTE_BIT: + case XGL_QUEUE_DMA_BIT: + case XGL_QUEUE_EXTENDED_BIT: + case XGL_QUEUE_GRAPHICS_BIT: return 1; default: return 0; @@ -1195,28 +1137,19 @@ static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) } -static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) +static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value) { - switch ((XGL_IMAGE_FORMAT_CLASS)input_value) + switch ((XGL_MEMORY_INPUT_FLAGS)input_value) { - case XGL_IMAGE_FORMAT_CLASS_128_BITS: - case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK: - case XGL_IMAGE_FORMAT_CLASS_16_BITS: - case XGL_IMAGE_FORMAT_CLASS_24_BITS: - case XGL_IMAGE_FORMAT_CLASS_32_BITS: - case XGL_IMAGE_FORMAT_CLASS_48_BITS: - case XGL_IMAGE_FORMAT_CLASS_64_BITS: - case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK: - case XGL_IMAGE_FORMAT_CLASS_8_BITS: - case XGL_IMAGE_FORMAT_CLASS_96_BITS: - case XGL_IMAGE_FORMAT_CLASS_D16: - case XGL_IMAGE_FORMAT_CLASS_D16S8: - case XGL_IMAGE_FORMAT_CLASS_D24: - case XGL_IMAGE_FORMAT_CLASS_D24S8: - case XGL_IMAGE_FORMAT_CLASS_D32: - case XGL_IMAGE_FORMAT_CLASS_D32S8: - case XGL_IMAGE_FORMAT_CLASS_LINEAR: - case XGL_IMAGE_FORMAT_CLASS_S8: + case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT: + case XGL_MEMORY_INPUT_COPY_BIT: + case XGL_MEMORY_INPUT_CPU_READ_BIT: + case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT: + case XGL_MEMORY_INPUT_INDEX_FETCH_BIT: + case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT: + case XGL_MEMORY_INPUT_SHADER_READ_BIT: + case XGL_MEMORY_INPUT_UNIFORM_READ_BIT: + case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT: return 1; default: return 0; @@ -1224,13 +1157,12 @@ static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS in } -static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) { - switch ((XGL_ATTACHMENT_LOAD_OP)input_value) + switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) { - case XGL_ATTACHMENT_LOAD_OP_CLEAR: - case XGL_ATTACHMENT_LOAD_OP_DONT_CARE: - case XGL_ATTACHMENT_LOAD_OP_LOAD: + case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC: + case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: return 1; default: return 0; @@ -1238,12 +1170,65 @@ static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP in } -static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) +static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value) { - switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value) + switch ((XGL_STRUCTURE_TYPE)input_value) { - case XGL_PROVOKING_VERTEX_FIRST: - case XGL_PROVOKING_VERTEX_LAST: + 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; @@ -1251,50 +1236,15 @@ static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VE } -static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value) +static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) { - switch ((XGL_RESULT)input_value) + switch ((XGL_MEMORY_OUTPUT_FLAGS)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_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; @@ -1302,11 +1252,26 @@ static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value) } -static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) { - switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) + switch ((XGL_LOGIC_OP)input_value) { - case XGL_SEMAPHORE_CREATE_SHAREABLE_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; @@ -1314,15 +1279,11 @@ static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_ } -static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) +static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) { - switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) + switch ((XGL_FORMAT_INFO_TYPE)input_value) { - case XGL_SYSTEM_ALLOC_API_OBJECT: - case XGL_SYSTEM_ALLOC_DEBUG: - case XGL_SYSTEM_ALLOC_INTERNAL: - case XGL_SYSTEM_ALLOC_INTERNAL_SHADER: - case XGL_SYSTEM_ALLOC_INTERNAL_TEMP: + case XGL_INFO_TYPE_FORMAT_PROPERTIES: return 1; default: return 0; @@ -1330,18 +1291,16 @@ static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE inpu } -static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) +static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) { - switch ((XGL_STENCIL_OP)input_value) + switch ((XGL_CHANNEL_SWIZZLE)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_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; @@ -1349,12 +1308,53 @@ static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) } -static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) +static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) { - switch ((XGL_TIMESTAMP_TYPE)input_value) + switch ((XGL_PIPELINE_BIND_POINT)input_value) { - case XGL_TIMESTAMP_BOTTOM: - case XGL_TIMESTAMP_TOP: + case XGL_PIPELINE_BIND_POINT_COMPUTE: + case XGL_PIPELINE_BIND_POINT_GRAPHICS: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) +{ + switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value) + { + case XGL_PROVOKING_VERTEX_FIRST: + case XGL_PROVOKING_VERTEX_LAST: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_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_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; diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp index ac5f673..c3e12a2 100644 --- a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp +++ b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp @@ -23,7 +23,7 @@ *************************************************************************/ extern "C" { #include "glv_trace_packet_utils.h" -#include "glvtrace_xgl_packet_id.h" +#include "glv_vk_packet_id.h" } #include "glvdebug_xgl_settings.h" diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h index 69f6896..1c448f4 100644 --- a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h +++ b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h @@ -25,7 +25,7 @@ #ifndef GLVDEBUG_XGL_QGROUPFRAMESPROXYMODEL_H #define GLVDEBUG_XGL_QGROUPFRAMESPROXYMODEL_H -#include "glvtrace_xgl_packet_id.h" +#include "glv_vk_packet_id.h" #include "glvdebug_QTraceFileModel.h" #include diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt index c7a1caf..cf5e85a 100644 --- a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt +++ b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt @@ -9,17 +9,17 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR} ${SRC_DIR}/../../../include ${SR file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen) -add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h +add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvreplay_xgl_replay.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvreplay_xgl_replay.cpp - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-replay-h > glvreplay_xgl_replay.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-replay-c > glvreplay_xgl_replay.cpp COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen @@ -52,10 +52,10 @@ set(SRC_LIST ) set (HDR_LIST - codegen/glvtrace_xgl_packet_id.h - codegen/glvtrace_xgl_xgl_structs.h - codegen/glvtrace_xgl_xglwsix11ext_structs.h - codegen/glvtrace_xgl_xgldbg_structs.h + codegen/glv_vk_packet_id.h + codegen/glv_vk_vk_structs.h + codegen/glv_vk_vkwsix11ext_structs.h + codegen/glv_vk_vkdbg_structs.h codegen/xgl_enum_string_helper.h glvreplay_xgl.h glvreplay_xgl_settings.h diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h similarity index 99% rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h index d1dded3..d774f98 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h +++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h @@ -29,9 +29,9 @@ #include "glv_trace_packet_utils.h" #include "glv_trace_packet_identifiers.h" #include "glv_interconnect.h" -#include "glvtrace_xgl_xgl_structs.h" -#include "glvtrace_xgl_xgldbg_structs.h" -#include "glvtrace_xgl_xglwsix11ext_structs.h" +#include "glv_vk_vk_structs.h" +#include "glv_vk_vkdbg_structs.h" +#include "glv_vk_vkwsix11ext_structs.h" #include "xgl_enum_string_helper.h" #if defined(WIN32) #define snprintf _snprintf diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vk_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgl_structs.h rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vk_structs.h diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkdbg_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgldbg_structs.h rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkdbg_structs.h diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkwsix11ext_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkwsix11ext_structs.h diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp index a4ea29a..99c71bb 100644 --- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp +++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp @@ -36,10 +36,10 @@ #include glvreplay_settings *g_pReplaySettings; extern "C" { -#include "glvtrace_xgl_xgl_structs.h" -#include "glvtrace_xgl_xgldbg_structs.h" -#include "glvtrace_xgl_xglwsix11ext_structs.h" -#include "glvtrace_xgl_packet_id.h" +#include "glv_vk_vk_structs.h" +#include "glv_vk_vkdbg_structs.h" +#include "glv_vk_vkwsix11ext_structs.h" +#include "glv_vk_packet_id.h" #include "xgl_enum_string_helper.h" } @@ -295,6 +295,28 @@ void xglDisplay::resize_window(const unsigned int width, const unsigned int heig void xglDisplay::process_event() { } + +void objMemory::setCount(const uint32_t num) +{ + m_numAllocations = num; +} + +void objMemory::setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num) +{ + if (m_numAllocations != num && m_numAllocations != 0) + glv_LogError("objMemory::setReqs, internal mismatch on number of allocations"); + if (m_pMemReqs == NULL && pReqs != NULL) + { + m_pMemReqs = (XGL_MEMORY_REQUIREMENTS *) glv_malloc(num * sizeof(XGL_MEMORY_REQUIREMENTS)); + if (m_pMemReqs == NULL) + { + glv_LogError("objMemory::setReqs out of memory"); + return; + } + memcpy(m_pMemReqs, pReqs, num); + } +} + xglReplay::xglReplay(glvreplay_settings *pReplaySettings) { g_pReplaySettings = pReplaySettings; @@ -302,6 +324,7 @@ xglReplay::xglReplay(glvreplay_settings *pReplaySettings) m_pDSDump = NULL; m_pCBDump = NULL; m_pGlvSnapshotPrint = NULL; + m_adjustForGPU = false; if (g_pReplaySettings && g_pReplaySettings->screenshotList) { process_screenshot_list(g_pReplaySettings->screenshotList); } @@ -856,12 +879,12 @@ glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet) case GLV_TPI_XGL_xglAllocMemory: { struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)(packet->pBody); - XGL_GPU_MEMORY local_pMem; - replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &local_pMem); + struct gpuMemObj local_mem; + replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem); if (replayResult == XGL_SUCCESS) { - add_to_map(pPacket->pMem, &local_pMem); - add_entry_to_mapData(local_pMem, pPacket->pAllocInfo->allocationSize); + add_to_map(pPacket->pMem, &local_mem); + add_entry_to_mapData(local_mem.replayGpuMem, pPacket->pAllocInfo->allocationSize); } CHECK_RETURN_VALUE(xglAllocMemory); break; @@ -869,11 +892,11 @@ glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet) case GLV_TPI_XGL_xglFreeMemory: { struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)(packet->pBody); - XGL_GPU_MEMORY handle = remap(pPacket->mem); - replayResult = m_xglFuncs.real_xglFreeMemory(handle); + XGL_GPU_MEMORY local_mem = remap(pPacket->mem); + replayResult = m_xglFuncs.real_xglFreeMemory(local_mem); if (replayResult == XGL_SUCCESS) { - rm_entry_from_mapData(handle); + rm_entry_from_mapData(local_mem); rm_from_map(pPacket->mem); } CHECK_RETURN_VALUE(xglFreeMemory); @@ -889,32 +912,30 @@ glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet) case GLV_TPI_XGL_xglMapMemory: { struct_xglMapMemory* pPacket = (struct_xglMapMemory*)(packet->pBody); - XGL_GPU_MEMORY handle = remap(pPacket->mem); + XGL_GPU_MEMORY local_mem = remap(pPacket->mem); void* pData; - replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData); + replayResult = m_xglFuncs.real_xglMapMemory(local_mem, pPacket->flags, &pData); if (replayResult == XGL_SUCCESS) - add_mapping_to_mapData(handle, pData); + add_mapping_to_mapData(local_mem, pData); CHECK_RETURN_VALUE(xglMapMemory); break; } case GLV_TPI_XGL_xglUnmapMemory: { struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)(packet->pBody); - XGL_GPU_MEMORY handle = remap(pPacket->mem); - rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer - replayResult = m_xglFuncs.real_xglUnmapMemory(handle); + XGL_GPU_MEMORY local_mem = remap(pPacket->mem); + rm_mapping_from_mapData(local_mem, pPacket->pData); // copies data from packet into memory buffer + replayResult = m_xglFuncs.real_xglUnmapMemory(local_mem); CHECK_RETURN_VALUE(xglUnmapMemory); break; } case GLV_TPI_XGL_xglPinSystemMemory: { struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)(packet->pBody); - XGL_GPU_MEMORY local_pMem; - replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_pMem); + struct gpuMemObj local_mem; + replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem); if (replayResult == XGL_SUCCESS) - { - add_to_map(pPacket->pMem, &local_pMem); - } + add_to_map(pPacket->pMem, &local_mem); CHECK_RETURN_VALUE(xglPinSystemMemory); break; } @@ -992,16 +1013,55 @@ glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet) pData = glv_malloc(*pPacket->pDataSize); memcpy(pData, pPacket->pData, *pPacket->pDataSize); } + // TODO only search for object once rather than at remap() and init_objMemXXX() replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData); if (replayResult == XGL_SUCCESS) { if (size != *pPacket->pDataSize && pData != NULL) { glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize); - } - else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0) + } else if (pData != NULL) { - glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\n"); + switch (pPacket->infoType) + { + case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT: + { + uint32_t traceCount = *((uint32_t *) pPacket->pData); + uint32_t replayCount = *((uint32_t *) pData); + if (traceCount != replayCount) + glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_ALLOCATION_COUNT) mismatch: trace count %u, replay count %u\n", traceCount, replayCount); + if (m_adjustForGPU) + init_objMemCount(pPacket->object, replayCount); + break; + } + case XGL_INFO_TYPE_MEMORY_REQUIREMENTS: + { + XGL_MEMORY_REQUIREMENTS *traceReqs = (XGL_MEMORY_REQUIREMENTS *) pPacket->pData; + XGL_MEMORY_REQUIREMENTS *replayReqs = (XGL_MEMORY_REQUIREMENTS *) pData; + unsigned int num = size / sizeof(XGL_MEMORY_REQUIREMENTS); + for (unsigned int i = 0; i < num; i++) + { + if (traceReqs->size != replayReqs->size) + glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace size %u, replay size %u\n", traceReqs->size, replayReqs->size); + if (traceReqs->alignment != replayReqs->alignment) + glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace alignment %u, replay aligmnent %u\n", traceReqs->alignment, replayReqs->alignment); + if (traceReqs->granularity != replayReqs->granularity) + glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace granularity %u, replay granularity %u\n", traceReqs->granularity, replayReqs->granularity); + if (traceReqs->memProps != replayReqs->memProps) + glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memProps %u, replay memProps %u\n", traceReqs->memProps, replayReqs->memProps); + if (traceReqs->memType != replayReqs->memType) + glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memType %u, replay memType %u\n", traceReqs->memType, replayReqs->memType); + traceReqs++; + replayReqs++; + } + if (m_adjustForGPU) + init_objMemReqs(pPacket->object, replayReqs - num, num); + break; + } + default: + if (memcmp(pData, pPacket->pData, size) != 0) + glv_LogWarn("xglGetObjectInfo() mismatch on *pData: between trace and replay *pDataSize %u\n", size); + } } } glv_free(pData); @@ -1174,11 +1234,11 @@ glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet) case GLV_TPI_XGL_xglCreateBuffer: { struct_xglCreateBuffer* pPacket = (struct_xglCreateBuffer*)(packet->pBody); - XGL_BUFFER local_pBuffer; - replayResult = m_xglFuncs.real_xglCreateBuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_pBuffer); + struct bufferObj local_bufferObj; + replayResult = m_xglFuncs.real_xglCreateBuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer); if (replayResult == XGL_SUCCESS) { - add_to_map(pPacket->pBuffer, &local_pBuffer); + add_to_map(pPacket->pBuffer, &local_bufferObj); } CHECK_RETURN_VALUE(xglCreateBuffer); break; @@ -1201,11 +1261,11 @@ glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet) case GLV_TPI_XGL_xglCreateImage: { struct_xglCreateImage* pPacket = (struct_xglCreateImage*)(packet->pBody); - XGL_IMAGE local_pImage; - replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &local_pImage); + struct imageObj local_imageObj; + replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage); if (replayResult == XGL_SUCCESS) { - add_to_map(pPacket->pImage, &local_pImage); + add_to_map(pPacket->pImage, &local_imageObj); } CHECK_RETURN_VALUE(xglCreateImage); break; @@ -2164,19 +2224,19 @@ glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet) { struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)(packet->pBody); #if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA) - XGL_IMAGE img; - XGL_GPU_MEMORY mem; + struct imageObj local_imgObj; + struct gpuMemObj local_mem; m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height); m_display->imageWidth.push_back(pPacket->pCreateInfo->extent.width); - replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem); + replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imgObj.replayImage, &local_mem.replayGpuMem); if (replayResult == XGL_SUCCESS) { if (pPacket->pImage != NULL) - add_to_map(pPacket->pImage, &img); + add_to_map(pPacket->pImage, &local_imgObj); if(pPacket->pMem != NULL) - add_to_map(pPacket->pMem, &mem); - m_display->imageHandles.push_back(img); - m_display->imageMemory.push_back(mem); + add_to_map(pPacket->pMem, &local_mem); + m_display->imageHandles.push_back(local_imgObj.replayImage); + m_display->imageMemory.push_back(local_mem.replayGpuMem); } #elif defined(WIN32) //TBD diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h index d35a8af..df55449 100644 --- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h +++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h @@ -105,6 +105,18 @@ typedef struct _XGLAllocInfo { XGL_GPU_SIZE size; void *pData; } XGLAllocInfo; + +class objMemory { +public: + objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {} + ~objMemory() { free(m_pMemReqs);} + void setCount(const uint32_t num); + void setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num); +private: + uint32_t m_numAllocations; + XGL_MEMORY_REQUIREMENTS *m_pMemReqs; +}; + struct xglFuncs { void init_funcs(void * libHandle); void *m_libHandle; @@ -806,6 +818,7 @@ private: }; std::vector m_validationMsgs; std::vector m_screenshotFrames; + // memory mapping functions for app writes into mapped memory std::map m_mapData; void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size) { @@ -856,19 +869,63 @@ private: info.pData = NULL; } - /*std::map m_gpus; - void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu) + bool m_adjustForGPU; // true if replay adjusts behavior based on GPU + struct imageObj { + objMemory imageMem; + XGL_IMAGE replayImage; + }; + + struct bufferObj { + objMemory bufferMem; + XGL_BUFFER replayBuffer; + }; + + struct gpuMemObj { + objMemory gpuMem; + XGL_GPU_MEMORY replayGpuMem; + }; + + void init_objMemCount(const XGL_BASE_OBJECT& object, const uint32_t &num) { - assert(pTraceGpu != NULL); - assert(pReplayGpu != NULL); - m_gpus[*pTraceGpu] = *pReplayGpu; + XGL_IMAGE img = static_cast (object); + std::map::const_iterator it = m_images.find(img); + if (it != m_images.end()) + { + objMemory obj = it->second.imageMem; + obj.setCount(num); + return; + } + XGL_BUFFER buf = static_cast (object); + std::map::const_iterator itb = m_buffers.find(buf); + if (itb != m_buffers.end()) + { + objMemory obj = itb->second.bufferMem; + obj.setCount(num); + return; + } + return; } - XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu) + void init_objMemReqs(const XGL_BASE_OBJECT& object, const XGL_MEMORY_REQUIREMENTS *pMemReqs, const unsigned int num) { - std::map::const_iterator q = m_gpus.find(gpu); - return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second; - }*/ + XGL_IMAGE img = static_cast (object); + std::map::const_iterator it = m_images.find(img); + if (it != m_images.end()) + { + objMemory obj = it->second.imageMem; + obj.setReqs(pMemReqs, num); + return; + } + XGL_BUFFER buf = static_cast (object); + std::map::const_iterator itb = m_buffers.find(buf); + if (itb != m_buffers.end()) + { + objMemory obj = itb->second.bufferMem; + obj.setReqs(pMemReqs, num); + return; + } + return; + } void clear_all_map_handles() { @@ -902,6 +959,7 @@ private: m_samplers.clear(); m_shaders.clear(); } + std::map m_bufferViews; void add_to_map(XGL_BUFFER_VIEW* pTraceVal, XGL_BUFFER_VIEW* pReplayVal) { @@ -909,31 +967,37 @@ private: assert(pReplayVal != NULL); m_bufferViews[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_BUFFER_VIEW& key) { m_bufferViews.erase(key); } + XGL_BUFFER_VIEW remap(const XGL_BUFFER_VIEW& value) { std::map::const_iterator q = m_bufferViews.find(value); return (q == m_bufferViews.end()) ? XGL_NULL_HANDLE : q->second; } - std::map m_buffers; - void add_to_map(XGL_BUFFER* pTraceVal, XGL_BUFFER* pReplayVal) + + std::map m_buffers; + void add_to_map(XGL_BUFFER* pTraceVal, struct bufferObj* pReplayVal) { assert(pTraceVal != NULL); assert(pReplayVal != NULL); m_buffers[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_BUFFER& key) { m_buffers.erase(key); } + XGL_BUFFER remap(const XGL_BUFFER& value) { - std::map::const_iterator q = m_buffers.find(value); - return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second; + std::map::const_iterator q = m_buffers.find(value); + return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second.replayBuffer; } + std::map m_cmdBuffers; void add_to_map(XGL_CMD_BUFFER* pTraceVal, XGL_CMD_BUFFER* pReplayVal) { @@ -941,15 +1005,18 @@ private: assert(pReplayVal != NULL); m_cmdBuffers[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_CMD_BUFFER& key) { m_cmdBuffers.erase(key); } + XGL_CMD_BUFFER remap(const XGL_CMD_BUFFER& value) { std::map::const_iterator q = m_cmdBuffers.find(value); return (q == m_cmdBuffers.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_colorAttachmentViews; void add_to_map(XGL_COLOR_ATTACHMENT_VIEW* pTraceVal, XGL_COLOR_ATTACHMENT_VIEW* pReplayVal) { @@ -957,15 +1024,18 @@ private: assert(pReplayVal != NULL); m_colorAttachmentViews[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_COLOR_ATTACHMENT_VIEW& key) { m_colorAttachmentViews.erase(key); } + XGL_COLOR_ATTACHMENT_VIEW remap(const XGL_COLOR_ATTACHMENT_VIEW& value) { std::map::const_iterator q = m_colorAttachmentViews.find(value); return (q == m_colorAttachmentViews.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_depthStencilViews; void add_to_map(XGL_DEPTH_STENCIL_VIEW* pTraceVal, XGL_DEPTH_STENCIL_VIEW* pReplayVal) { @@ -973,15 +1043,18 @@ private: assert(pReplayVal != NULL); m_depthStencilViews[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DEPTH_STENCIL_VIEW& key) { m_depthStencilViews.erase(key); } + XGL_DEPTH_STENCIL_VIEW remap(const XGL_DEPTH_STENCIL_VIEW& value) { std::map::const_iterator q = m_depthStencilViews.find(value); return (q == m_depthStencilViews.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_descriptorRegions; void add_to_map(XGL_DESCRIPTOR_REGION* pTraceVal, XGL_DESCRIPTOR_REGION* pReplayVal) { @@ -989,15 +1062,18 @@ private: assert(pReplayVal != NULL); m_descriptorRegions[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DESCRIPTOR_REGION& key) { m_descriptorRegions.erase(key); } + XGL_DESCRIPTOR_REGION remap(const XGL_DESCRIPTOR_REGION& value) { std::map::const_iterator q = m_descriptorRegions.find(value); return (q == m_descriptorRegions.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_descriptorSetLayouts; void add_to_map(XGL_DESCRIPTOR_SET_LAYOUT* pTraceVal, XGL_DESCRIPTOR_SET_LAYOUT* pReplayVal) { @@ -1005,15 +1081,18 @@ private: assert(pReplayVal != NULL); m_descriptorSetLayouts[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DESCRIPTOR_SET_LAYOUT& key) { m_descriptorSetLayouts.erase(key); } + XGL_DESCRIPTOR_SET_LAYOUT remap(const XGL_DESCRIPTOR_SET_LAYOUT& value) { std::map::const_iterator q = m_descriptorSetLayouts.find(value); return (q == m_descriptorSetLayouts.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_descriptorSets; void add_to_map(XGL_DESCRIPTOR_SET* pTraceVal, XGL_DESCRIPTOR_SET* pReplayVal) { @@ -1021,15 +1100,18 @@ private: assert(pReplayVal != NULL); m_descriptorSets[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DESCRIPTOR_SET& key) { m_descriptorSets.erase(key); } + XGL_DESCRIPTOR_SET remap(const XGL_DESCRIPTOR_SET& value) { std::map::const_iterator q = m_descriptorSets.find(value); return (q == m_descriptorSets.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_devices; void add_to_map(XGL_DEVICE* pTraceVal, XGL_DEVICE* pReplayVal) { @@ -1037,15 +1119,18 @@ private: assert(pReplayVal != NULL); m_devices[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DEVICE& key) { m_devices.erase(key); } + XGL_DEVICE remap(const XGL_DEVICE& value) { std::map::const_iterator q = m_devices.find(value); return (q == m_devices.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_dynamicCbStateObjects; void add_to_map(XGL_DYNAMIC_CB_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_CB_STATE_OBJECT* pReplayVal) { @@ -1053,15 +1138,18 @@ private: assert(pReplayVal != NULL); m_dynamicCbStateObjects[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DYNAMIC_CB_STATE_OBJECT& key) { m_dynamicCbStateObjects.erase(key); } + XGL_DYNAMIC_CB_STATE_OBJECT remap(const XGL_DYNAMIC_CB_STATE_OBJECT& value) { std::map::const_iterator q = m_dynamicCbStateObjects.find(value); return (q == m_dynamicCbStateObjects.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_dynamicDsStateObjects; void add_to_map(XGL_DYNAMIC_DS_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_DS_STATE_OBJECT* pReplayVal) { @@ -1069,15 +1157,18 @@ private: assert(pReplayVal != NULL); m_dynamicDsStateObjects[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DYNAMIC_DS_STATE_OBJECT& key) { m_dynamicDsStateObjects.erase(key); } + XGL_DYNAMIC_DS_STATE_OBJECT remap(const XGL_DYNAMIC_DS_STATE_OBJECT& value) { std::map::const_iterator q = m_dynamicDsStateObjects.find(value); return (q == m_dynamicDsStateObjects.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_dynamicRsStateObjects; void add_to_map(XGL_DYNAMIC_RS_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_RS_STATE_OBJECT* pReplayVal) { @@ -1085,15 +1176,18 @@ private: assert(pReplayVal != NULL); m_dynamicRsStateObjects[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DYNAMIC_RS_STATE_OBJECT& key) { m_dynamicRsStateObjects.erase(key); } + XGL_DYNAMIC_RS_STATE_OBJECT remap(const XGL_DYNAMIC_RS_STATE_OBJECT& value) { std::map::const_iterator q = m_dynamicRsStateObjects.find(value); return (q == m_dynamicRsStateObjects.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_dynamicVpStateObjects; void add_to_map(XGL_DYNAMIC_VP_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_VP_STATE_OBJECT* pReplayVal) { @@ -1101,15 +1195,18 @@ private: assert(pReplayVal != NULL); m_dynamicVpStateObjects[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_DYNAMIC_VP_STATE_OBJECT& key) { m_dynamicVpStateObjects.erase(key); } + XGL_DYNAMIC_VP_STATE_OBJECT remap(const XGL_DYNAMIC_VP_STATE_OBJECT& value) { std::map::const_iterator q = m_dynamicVpStateObjects.find(value); return (q == m_dynamicVpStateObjects.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_events; void add_to_map(XGL_EVENT* pTraceVal, XGL_EVENT* pReplayVal) { @@ -1117,15 +1214,18 @@ private: assert(pReplayVal != NULL); m_events[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_EVENT& key) { m_events.erase(key); } + XGL_EVENT remap(const XGL_EVENT& value) { std::map::const_iterator q = m_events.find(value); return (q == m_events.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_fences; void add_to_map(XGL_FENCE* pTraceVal, XGL_FENCE* pReplayVal) { @@ -1133,15 +1233,18 @@ private: assert(pReplayVal != NULL); m_fences[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_FENCE& key) { m_fences.erase(key); } + XGL_FENCE remap(const XGL_FENCE& value) { std::map::const_iterator q = m_fences.find(value); return (q == m_fences.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_framebuffers; void add_to_map(XGL_FRAMEBUFFER* pTraceVal, XGL_FRAMEBUFFER* pReplayVal) { @@ -1149,31 +1252,37 @@ private: assert(pReplayVal != NULL); m_framebuffers[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_FRAMEBUFFER& key) { m_framebuffers.erase(key); } + XGL_FRAMEBUFFER remap(const XGL_FRAMEBUFFER& value) { std::map::const_iterator q = m_framebuffers.find(value); return (q == m_framebuffers.end()) ? XGL_NULL_HANDLE : q->second; } - std::map m_gpuMemorys; - void add_to_map(XGL_GPU_MEMORY* pTraceVal, XGL_GPU_MEMORY* pReplayVal) + + std::map m_gpuMemorys; + void add_to_map(XGL_GPU_MEMORY* pTraceVal, struct gpuMemObj* pReplayVal) { assert(pTraceVal != NULL); assert(pReplayVal != NULL); m_gpuMemorys[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_GPU_MEMORY& key) { m_gpuMemorys.erase(key); } + XGL_GPU_MEMORY remap(const XGL_GPU_MEMORY& value) { - std::map::const_iterator q = m_gpuMemorys.find(value); - return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second; + std::map::const_iterator q = m_gpuMemorys.find(value); + return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second.replayGpuMem; } + std::map m_imageViews; void add_to_map(XGL_IMAGE_VIEW* pTraceVal, XGL_IMAGE_VIEW* pReplayVal) { @@ -1181,31 +1290,37 @@ private: assert(pReplayVal != NULL); m_imageViews[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_IMAGE_VIEW& key) { m_imageViews.erase(key); } + XGL_IMAGE_VIEW remap(const XGL_IMAGE_VIEW& value) { std::map::const_iterator q = m_imageViews.find(value); return (q == m_imageViews.end()) ? XGL_NULL_HANDLE : q->second; } - std::map m_images; - void add_to_map(XGL_IMAGE* pTraceVal, XGL_IMAGE* pReplayVal) + + std::map m_images; + void add_to_map(XGL_IMAGE* pTraceVal, struct imageObj* pReplayVal) { assert(pTraceVal != NULL); assert(pReplayVal != NULL); m_images[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_IMAGE& key) { m_images.erase(key); } + XGL_IMAGE remap(const XGL_IMAGE& value) { - std::map::const_iterator q = m_images.find(value); - return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second; + std::map::const_iterator q = m_images.find(value); + return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second.replayImage; } + std::map m_instances; void add_to_map(XGL_INSTANCE* pTraceVal, XGL_INSTANCE* pReplayVal) { @@ -1213,15 +1328,18 @@ private: assert(pReplayVal != NULL); m_instances[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_INSTANCE& key) { m_instances.erase(key); } + XGL_INSTANCE remap(const XGL_INSTANCE& value) { std::map::const_iterator q = m_instances.find(value); return (q == m_instances.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_physicalGpus; void add_to_map(XGL_PHYSICAL_GPU* pTraceVal, XGL_PHYSICAL_GPU* pReplayVal) { @@ -1229,15 +1347,18 @@ private: assert(pReplayVal != NULL); m_physicalGpus[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_PHYSICAL_GPU& key) { m_physicalGpus.erase(key); } + XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& value) { std::map::const_iterator q = m_physicalGpus.find(value); return (q == m_physicalGpus.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_pipelineDeltas; void add_to_map(XGL_PIPELINE_DELTA* pTraceVal, XGL_PIPELINE_DELTA* pReplayVal) { @@ -1245,15 +1366,18 @@ private: assert(pReplayVal != NULL); m_pipelineDeltas[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_PIPELINE_DELTA& key) { m_pipelineDeltas.erase(key); } + XGL_PIPELINE_DELTA remap(const XGL_PIPELINE_DELTA& value) { std::map::const_iterator q = m_pipelineDeltas.find(value); return (q == m_pipelineDeltas.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_pipelines; void add_to_map(XGL_PIPELINE* pTraceVal, XGL_PIPELINE* pReplayVal) { @@ -1261,15 +1385,18 @@ private: assert(pReplayVal != NULL); m_pipelines[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_PIPELINE& key) { m_pipelines.erase(key); } + XGL_PIPELINE remap(const XGL_PIPELINE& value) { std::map::const_iterator q = m_pipelines.find(value); return (q == m_pipelines.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_queryPools; void add_to_map(XGL_QUERY_POOL* pTraceVal, XGL_QUERY_POOL* pReplayVal) { @@ -1277,15 +1404,18 @@ private: assert(pReplayVal != NULL); m_queryPools[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_QUERY_POOL& key) { m_queryPools.erase(key); } + XGL_QUERY_POOL remap(const XGL_QUERY_POOL& value) { std::map::const_iterator q = m_queryPools.find(value); return (q == m_queryPools.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_queueSemaphores; void add_to_map(XGL_QUEUE_SEMAPHORE* pTraceVal, XGL_QUEUE_SEMAPHORE* pReplayVal) { @@ -1293,15 +1423,18 @@ private: assert(pReplayVal != NULL); m_queueSemaphores[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_QUEUE_SEMAPHORE& key) { m_queueSemaphores.erase(key); } + XGL_QUEUE_SEMAPHORE remap(const XGL_QUEUE_SEMAPHORE& value) { std::map::const_iterator q = m_queueSemaphores.find(value); return (q == m_queueSemaphores.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_queues; void add_to_map(XGL_QUEUE* pTraceVal, XGL_QUEUE* pReplayVal) { @@ -1309,15 +1442,18 @@ private: assert(pReplayVal != NULL); m_queues[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_QUEUE& key) { m_queues.erase(key); } + XGL_QUEUE remap(const XGL_QUEUE& value) { std::map::const_iterator q = m_queues.find(value); return (q == m_queues.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_renderPasss; void add_to_map(XGL_RENDER_PASS* pTraceVal, XGL_RENDER_PASS* pReplayVal) { @@ -1325,15 +1461,18 @@ private: assert(pReplayVal != NULL); m_renderPasss[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_RENDER_PASS& key) { m_renderPasss.erase(key); } + XGL_RENDER_PASS remap(const XGL_RENDER_PASS& value) { std::map::const_iterator q = m_renderPasss.find(value); return (q == m_renderPasss.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_samplers; void add_to_map(XGL_SAMPLER* pTraceVal, XGL_SAMPLER* pReplayVal) { @@ -1341,15 +1480,18 @@ private: assert(pReplayVal != NULL); m_samplers[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_SAMPLER& key) { m_samplers.erase(key); } + XGL_SAMPLER remap(const XGL_SAMPLER& value) { std::map::const_iterator q = m_samplers.find(value); return (q == m_samplers.end()) ? XGL_NULL_HANDLE : q->second; } + std::map m_shaders; void add_to_map(XGL_SHADER* pTraceVal, XGL_SHADER* pReplayVal) { @@ -1357,15 +1499,18 @@ private: assert(pReplayVal != NULL); m_shaders[*pTraceVal] = *pReplayVal; } + void rm_from_map(const XGL_SHADER& key) { m_shaders.erase(key); } + XGL_SHADER remap(const XGL_SHADER& value) { std::map::const_iterator q = m_shaders.find(value); return (q == m_shaders.end()) ? XGL_NULL_HANDLE : q->second; } + XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state) { XGL_DYNAMIC_STATE_OBJECT obj; @@ -1386,6 +1531,7 @@ private: rm_from_map(static_cast (state)); rm_from_map(static_cast (state)); } + XGL_OBJECT remap(const XGL_OBJECT& object) { XGL_OBJECT obj; diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h index 0c581ef..d68bb20 100644 --- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h +++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h @@ -3,70 +3,16 @@ #include -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_BLEND_FUNC(XGL_BLEND_FUNC input_value) -{ - switch ((XGL_BLEND_FUNC)input_value) - { - case XGL_BLEND_FUNC_ADD: - return "XGL_BLEND_FUNC_ADD"; - case XGL_BLEND_FUNC_MAX: - return "XGL_BLEND_FUNC_MAX"; - case XGL_BLEND_FUNC_MIN: - return "XGL_BLEND_FUNC_MIN"; - case XGL_BLEND_FUNC_REVERSE_SUBTRACT: - return "XGL_BLEND_FUNC_REVERSE_SUBTRACT"; - case XGL_BLEND_FUNC_SUBTRACT: - return "XGL_BLEND_FUNC_SUBTRACT"; - default: - return "Unhandled XGL_BLEND_FUNC"; - } -} - - -static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) +static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) { - switch ((XGL_MEMORY_REF_FLAGS)input_value) + switch ((XGL_DEPTH_MODE)input_value) { - case XGL_MEMORY_REF_READ_ONLY_BIT: - return "XGL_MEMORY_REF_READ_ONLY_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_MEMORY_REF_FLAGS"; + return "Unhandled XGL_DEPTH_MODE"; } } @@ -89,180 +35,40 @@ static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_v } -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_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_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_LOGIC_OP(XGL_LOGIC_OP input_value) -{ - switch ((XGL_LOGIC_OP)input_value) - { - case XGL_LOGIC_OP_AND: - return "XGL_LOGIC_OP_AND"; - case XGL_LOGIC_OP_AND_INVERTED: - return "XGL_LOGIC_OP_AND_INVERTED"; - case XGL_LOGIC_OP_AND_REVERSE: - return "XGL_LOGIC_OP_AND_REVERSE"; - case XGL_LOGIC_OP_CLEAR: - return "XGL_LOGIC_OP_CLEAR"; - case XGL_LOGIC_OP_COPY: - return "XGL_LOGIC_OP_COPY"; - case XGL_LOGIC_OP_COPY_INVERTED: - return "XGL_LOGIC_OP_COPY_INVERTED"; - case XGL_LOGIC_OP_EQUIV: - return "XGL_LOGIC_OP_EQUIV"; - case XGL_LOGIC_OP_INVERT: - return "XGL_LOGIC_OP_INVERT"; - case XGL_LOGIC_OP_NAND: - return "XGL_LOGIC_OP_NAND"; - case XGL_LOGIC_OP_NOOP: - return "XGL_LOGIC_OP_NOOP"; - case XGL_LOGIC_OP_NOR: - return "XGL_LOGIC_OP_NOR"; - case XGL_LOGIC_OP_OR: - return "XGL_LOGIC_OP_OR"; - case XGL_LOGIC_OP_OR_INVERTED: - return "XGL_LOGIC_OP_OR_INVERTED"; - case XGL_LOGIC_OP_OR_REVERSE: - return "XGL_LOGIC_OP_OR_REVERSE"; - case XGL_LOGIC_OP_SET: - return "XGL_LOGIC_OP_SET"; - case XGL_LOGIC_OP_XOR: - return "XGL_LOGIC_OP_XOR"; - default: - return "Unhandled XGL_LOGIC_OP"; - } -} - - -static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) -{ - switch ((XGL_DESCRIPTOR_TYPE)input_value) - { - case XGL_DESCRIPTOR_TYPE_IMAGE: - return "XGL_DESCRIPTOR_TYPE_IMAGE"; - case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER: - return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER"; - case XGL_DESCRIPTOR_TYPE_RAW_BUFFER: - return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER"; - case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC: - return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC"; - case XGL_DESCRIPTOR_TYPE_SAMPLER: - return "XGL_DESCRIPTOR_TYPE_SAMPLER"; - case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE: - return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE"; - case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER: - return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER"; - case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC: - return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC"; - case XGL_DESCRIPTOR_TYPE_TEXTURE: - return "XGL_DESCRIPTOR_TYPE_TEXTURE"; - case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER: - return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER"; - case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER"; - case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"; - default: - return "Unhandled XGL_DESCRIPTOR_TYPE"; - } -} - - -static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) +static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) { - switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) + switch ((XGL_PIPELINE_BIND_POINT)input_value) { - case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: - return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT"; + 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_SUBRESOURCE_INFO_TYPE"; + return "Unhandled XGL_PIPELINE_BIND_POINT"; } } -static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) +static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) { - switch ((XGL_MEMORY_TYPE)input_value) + switch ((XGL_MEMORY_REF_FLAGS)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_MEMORY_REF_READ_ONLY_BIT: + return "XGL_MEMORY_REF_READ_ONLY_BIT"; default: - return "Unhandled XGL_MEMORY_TYPE"; + return "Unhandled XGL_MEMORY_REF_FLAGS"; } } -static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) +static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) { - switch ((XGL_MEMORY_PRIORITY)input_value) + switch ((XGL_PIPELINE_CREATE_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_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: + return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; default: - return "Unhandled XGL_MEMORY_PRIORITY"; + return "Unhandled XGL_PIPELINE_CREATE_FLAGS"; } } @@ -283,16 +89,16 @@ static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STE } -static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) +static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) { - switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value) + switch ((XGL_QUERY_TYPE)input_value) { - case XGL_DESCRIPTOR_UDPATE_MODE_COPY: - return "XGL_DESCRIPTOR_UDPATE_MODE_COPY"; - case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST: - return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST"; + case XGL_QUERY_OCCLUSION: + return "XGL_QUERY_OCCLUSION"; + case XGL_QUERY_PIPELINE_STATISTICS: + return "XGL_QUERY_PIPELINE_STATISTICS"; default: - return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE"; + return "Unhandled XGL_QUERY_TYPE"; } } @@ -313,52 +119,30 @@ static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP } -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_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) +static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) { - switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) + switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) { - case XGL_SYSTEM_ALLOC_API_OBJECT: - return "XGL_SYSTEM_ALLOC_API_OBJECT"; - case XGL_SYSTEM_ALLOC_DEBUG: - return "XGL_SYSTEM_ALLOC_DEBUG"; - case XGL_SYSTEM_ALLOC_INTERNAL: - return "XGL_SYSTEM_ALLOC_INTERNAL"; - case XGL_SYSTEM_ALLOC_INTERNAL_SHADER: - return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER"; - case XGL_SYSTEM_ALLOC_INTERNAL_TEMP: - return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP"; + case XGL_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_SYSTEM_ALLOC_TYPE"; + return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS"; } } -static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) +static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) { - switch ((XGL_DEPTH_MODE)input_value) + switch ((XGL_TIMESTAMP_TYPE)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_TIMESTAMP_BOTTOM: + return "XGL_TIMESTAMP_BOTTOM"; + case XGL_TIMESTAMP_TOP: + return "XGL_TIMESTAMP_TOP"; default: - return "Unhandled XGL_DEPTH_MODE"; + return "Unhandled XGL_TIMESTAMP_TYPE"; } } @@ -377,176 +161,100 @@ static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) } -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_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_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_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_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) +static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) { - switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) + switch ((XGL_IMAGE_ASPECT)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_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_GPU_COMPATIBILITY_FLAGS"; + return "Unhandled XGL_IMAGE_ASPECT"; } } -static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) +static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) { - switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) + switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value) { - case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: - return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_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_PIPELINE_CREATE_FLAGS"; + return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE"; } } -static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value) +static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) { - switch ((XGL_DEVICE_CREATE_FLAGS)input_value) + switch ((XGL_SEMAPHORE_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"; + case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: + return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT"; default: - return "Unhandled XGL_DEVICE_CREATE_FLAGS"; + return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS"; } } -static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) +static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) { - switch ((XGL_OBJECT_INFO_TYPE)input_value) + switch ((XGL_PHYSICAL_GPU_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"; + 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_OBJECT_INFO_TYPE"; + return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE"; } } -static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) +static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value) { - switch ((XGL_TEX_MIPMAP_MODE)input_value) + switch ((XGL_BUFFER_USAGE_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_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_TEX_MIPMAP_MODE"; + return "Unhandled XGL_BUFFER_USAGE_FLAGS"; } } @@ -671,158 +379,20 @@ static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_val } -static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) +static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value) { - switch ((XGL_TIMESTAMP_TYPE)input_value) + switch ((XGL_STATE_BIND_POINT)input_value) { - case XGL_TIMESTAMP_BOTTOM: - return "XGL_TIMESTAMP_BOTTOM"; - case XGL_TIMESTAMP_TOP: - return "XGL_TIMESTAMP_TOP"; - default: - return "Unhandled XGL_TIMESTAMP_TYPE"; - } -} - - -static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) -{ - switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value) - { - case XGL_PROVOKING_VERTEX_FIRST: - return "XGL_PROVOKING_VERTEX_FIRST"; - case XGL_PROVOKING_VERTEX_LAST: - return "XGL_PROVOKING_VERTEX_LAST"; - default: - return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION"; - } -} - - -static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) -{ - switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value) - { - case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES: - return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES"; - case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE: - return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE"; - case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES: - return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES"; - case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES: - return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES"; - default: - return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE"; - } -} - - -static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) -{ - switch ((XGL_TEX_FILTER)input_value) - { - case XGL_TEX_FILTER_LINEAR: - return "XGL_TEX_FILTER_LINEAR"; - case XGL_TEX_FILTER_NEAREST: - return "XGL_TEX_FILTER_NEAREST"; - default: - return "Unhandled XGL_TEX_FILTER"; - } -} - - -static inline const char* string_XGL_BLEND(XGL_BLEND input_value) -{ - switch ((XGL_BLEND)input_value) - { - case XGL_BLEND_CONSTANT_ALPHA: - return "XGL_BLEND_CONSTANT_ALPHA"; - case XGL_BLEND_CONSTANT_COLOR: - return "XGL_BLEND_CONSTANT_COLOR"; - case XGL_BLEND_DEST_ALPHA: - return "XGL_BLEND_DEST_ALPHA"; - case XGL_BLEND_DEST_COLOR: - return "XGL_BLEND_DEST_COLOR"; - case XGL_BLEND_ONE: - return "XGL_BLEND_ONE"; - case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA: - return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA"; - case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR: - return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR"; - case XGL_BLEND_ONE_MINUS_DEST_ALPHA: - return "XGL_BLEND_ONE_MINUS_DEST_ALPHA"; - case XGL_BLEND_ONE_MINUS_DEST_COLOR: - return "XGL_BLEND_ONE_MINUS_DEST_COLOR"; - case XGL_BLEND_ONE_MINUS_SRC1_ALPHA: - return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA"; - case XGL_BLEND_ONE_MINUS_SRC1_COLOR: - return "XGL_BLEND_ONE_MINUS_SRC1_COLOR"; - case XGL_BLEND_ONE_MINUS_SRC_ALPHA: - return "XGL_BLEND_ONE_MINUS_SRC_ALPHA"; - case XGL_BLEND_ONE_MINUS_SRC_COLOR: - return "XGL_BLEND_ONE_MINUS_SRC_COLOR"; - case XGL_BLEND_SRC1_ALPHA: - return "XGL_BLEND_SRC1_ALPHA"; - case XGL_BLEND_SRC1_COLOR: - return "XGL_BLEND_SRC1_COLOR"; - case XGL_BLEND_SRC_ALPHA: - return "XGL_BLEND_SRC_ALPHA"; - case XGL_BLEND_SRC_ALPHA_SATURATE: - return "XGL_BLEND_SRC_ALPHA_SATURATE"; - case XGL_BLEND_SRC_COLOR: - return "XGL_BLEND_SRC_COLOR"; - case XGL_BLEND_ZERO: - return "XGL_BLEND_ZERO"; - default: - return "Unhandled XGL_BLEND"; - } -} - - -static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) -{ - switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) - { - case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC: - return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC"; - case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: - return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT"; - default: - return "Unhandled XGL_DESCRIPTOR_REGION_USAGE"; - } -} - - -static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value) -{ - switch ((XGL_CULL_MODE)input_value) - { - case XGL_CULL_BACK: - return "XGL_CULL_BACK"; - case XGL_CULL_FRONT: - return "XGL_CULL_FRONT"; - case XGL_CULL_FRONT_AND_BACK: - return "XGL_CULL_FRONT_AND_BACK"; - case XGL_CULL_NONE: - return "XGL_CULL_NONE"; - default: - return "Unhandled XGL_CULL_MODE"; - } -} - - -static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value) -{ - switch ((XGL_BUFFER_VIEW_TYPE)input_value) - { - case XGL_BUFFER_VIEW_RAW: - return "XGL_BUFFER_VIEW_RAW"; - case XGL_BUFFER_VIEW_STRUCTURED: - return "XGL_BUFFER_VIEW_STRUCTURED"; - case XGL_BUFFER_VIEW_TYPED: - return "XGL_BUFFER_VIEW_TYPED"; + 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_BUFFER_VIEW_TYPE"; + return "Unhandled XGL_STATE_BIND_POINT"; } } @@ -917,22 +487,80 @@ static inline const char* string_XGL_RESULT(XGL_RESULT input_value) } -static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) +static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) { - switch ((XGL_IMAGE_CREATE_FLAGS)input_value) + switch ((XGL_OBJECT_INFO_TYPE)input_value) { - case XGL_IMAGE_CREATE_CLONEABLE_BIT: - return "XGL_IMAGE_CREATE_CLONEABLE_BIT"; - case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT: - return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT"; - case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT: - return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; - case XGL_IMAGE_CREATE_SHAREABLE_BIT: - return "XGL_IMAGE_CREATE_SHAREABLE_BIT"; - case XGL_IMAGE_CREATE_SPARSE_BIT: - return "XGL_IMAGE_CREATE_SPARSE_BIT"; + case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS: + return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS"; + case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS: + return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS"; + case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT: + return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT"; + case XGL_INFO_TYPE_MEMORY_REQUIREMENTS: + return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS"; default: - return "Unhandled XGL_IMAGE_CREATE_FLAGS"; + return "Unhandled XGL_OBJECT_INFO_TYPE"; + } +} + + +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_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"; } } @@ -957,332 +585,756 @@ static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) } -static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) +static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value) { - switch ((XGL_QUEUE_FLAGS)input_value) + switch ((XGL_PRIMITIVE_TOPOLOGY)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"; - } -} + 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_QUERY_TYPE(XGL_QUERY_TYPE input_value) +static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value) { - switch ((XGL_QUERY_TYPE)input_value) + switch ((XGL_DESCRIPTOR_SET_USAGE)input_value) { - case XGL_QUERY_OCCLUSION: - return "XGL_QUERY_OCCLUSION"; - case XGL_QUERY_PIPELINE_STATISTICS: - return "XGL_QUERY_PIPELINE_STATISTICS"; + 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_QUERY_TYPE"; + return "Unhandled XGL_DESCRIPTOR_SET_USAGE"; } } -static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) +static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) { - switch ((XGL_IMAGE_LAYOUT)input_value) + switch ((XGL_SUBRESOURCE_INFO_TYPE)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"; + case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: + return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT"; default: - return "Unhandled XGL_IMAGE_LAYOUT"; + return "Unhandled XGL_SUBRESOURCE_INFO_TYPE"; } } -static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) +static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) { - switch ((XGL_QUERY_CONTROL_FLAGS)input_value) + switch ((XGL_STENCIL_OP)input_value) { - case XGL_QUERY_IMPRECISE_DATA_BIT: - return "XGL_QUERY_IMPRECISE_DATA_BIT"; + 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_QUERY_CONTROL_FLAGS"; + return "Unhandled XGL_STENCIL_OP"; } } -static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) +static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value) { - switch ((XGL_FORMAT_INFO_TYPE)input_value) + switch ((XGL_BUFFER_VIEW_TYPE)input_value) { - case XGL_INFO_TYPE_FORMAT_PROPERTIES: - return "XGL_INFO_TYPE_FORMAT_PROPERTIES"; + 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_FORMAT_INFO_TYPE"; + return "Unhandled XGL_BUFFER_VIEW_TYPE"; } } -static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) +static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) { - switch ((XGL_PIPELINE_SHADER_STAGE)input_value) + switch ((XGL_PHYSICAL_GPU_TYPE)input_value) { - case XGL_SHADER_STAGE_COMPUTE: - return "XGL_SHADER_STAGE_COMPUTE"; - case XGL_SHADER_STAGE_FRAGMENT: - return "XGL_SHADER_STAGE_FRAGMENT"; - case XGL_SHADER_STAGE_GEOMETRY: - return "XGL_SHADER_STAGE_GEOMETRY"; - case XGL_SHADER_STAGE_TESS_CONTROL: - return "XGL_SHADER_STAGE_TESS_CONTROL"; - case XGL_SHADER_STAGE_TESS_EVALUATION: - return "XGL_SHADER_STAGE_TESS_EVALUATION"; - case XGL_SHADER_STAGE_VERTEX: - return "XGL_SHADER_STAGE_VERTEX"; + case XGL_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_PIPELINE_SHADER_STAGE"; + return "Unhandled XGL_PHYSICAL_GPU_TYPE"; } } -static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) +static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) { - switch ((XGL_COORDINATE_ORIGIN)input_value) + switch ((XGL_PROVOKING_VERTEX_CONVENTION)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_PROVOKING_VERTEX_FIRST: + return "XGL_PROVOKING_VERTEX_FIRST"; + case XGL_PROVOKING_VERTEX_LAST: + return "XGL_PROVOKING_VERTEX_LAST"; default: - return "Unhandled XGL_COORDINATE_ORIGIN"; + return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION"; } } -static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) +static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value) { - switch ((XGL_VALIDATION_LEVEL)input_value) + switch ((XGL_FORMAT_FEATURE_FLAGS)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_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_VALIDATION_LEVEL"; + return "Unhandled XGL_FORMAT_FEATURE_FLAGS"; } } -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_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) { - switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) + switch ((XGL_COORDINATE_ORIGIN)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_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_DEPTH_STENCIL_VIEW_CREATE_FLAGS"; + return "Unhandled XGL_COORDINATE_ORIGIN"; } } -static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) +static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) { - switch ((XGL_WAIT_EVENT)input_value) + switch ((XGL_MEMORY_PRIORITY)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_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_WAIT_EVENT"; + return "Unhandled XGL_MEMORY_PRIORITY"; } } -static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) +static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) { - switch ((XGL_BUFFER_CREATE_FLAGS)input_value) + switch ((XGL_MEMORY_PROPERTY_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_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT: + return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT"; + case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT: + return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT"; + case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT: + return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT"; + case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT: + return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT"; + case XGL_MEMORY_PROPERTY_GPU_ONLY: + return "XGL_MEMORY_PROPERTY_GPU_ONLY"; + case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL: + return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL"; + case XGL_MEMORY_PROPERTY_SHAREABLE_BIT: + return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT"; default: - return "Unhandled XGL_BUFFER_CREATE_FLAGS"; + return "Unhandled XGL_MEMORY_PROPERTY_FLAGS"; } } -static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value) +static inline const char* string_XGL_BLEND(XGL_BLEND input_value) { - switch ((XGL_SET_EVENT)input_value) + switch ((XGL_BLEND)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_BLEND_CONSTANT_ALPHA: + return "XGL_BLEND_CONSTANT_ALPHA"; + case XGL_BLEND_CONSTANT_COLOR: + return "XGL_BLEND_CONSTANT_COLOR"; + case XGL_BLEND_DEST_ALPHA: + return "XGL_BLEND_DEST_ALPHA"; + case XGL_BLEND_DEST_COLOR: + return "XGL_BLEND_DEST_COLOR"; + case XGL_BLEND_ONE: + return "XGL_BLEND_ONE"; + case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA: + return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA"; + case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR: + return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR"; + case XGL_BLEND_ONE_MINUS_DEST_ALPHA: + return "XGL_BLEND_ONE_MINUS_DEST_ALPHA"; + case XGL_BLEND_ONE_MINUS_DEST_COLOR: + return "XGL_BLEND_ONE_MINUS_DEST_COLOR"; + case XGL_BLEND_ONE_MINUS_SRC1_ALPHA: + return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA"; + case XGL_BLEND_ONE_MINUS_SRC1_COLOR: + return "XGL_BLEND_ONE_MINUS_SRC1_COLOR"; + case XGL_BLEND_ONE_MINUS_SRC_ALPHA: + return "XGL_BLEND_ONE_MINUS_SRC_ALPHA"; + case XGL_BLEND_ONE_MINUS_SRC_COLOR: + return "XGL_BLEND_ONE_MINUS_SRC_COLOR"; + case XGL_BLEND_SRC1_ALPHA: + return "XGL_BLEND_SRC1_ALPHA"; + case XGL_BLEND_SRC1_COLOR: + return "XGL_BLEND_SRC1_COLOR"; + case XGL_BLEND_SRC_ALPHA: + return "XGL_BLEND_SRC_ALPHA"; + case XGL_BLEND_SRC_ALPHA_SATURATE: + return "XGL_BLEND_SRC_ALPHA_SATURATE"; + case XGL_BLEND_SRC_COLOR: + return "XGL_BLEND_SRC_COLOR"; + case XGL_BLEND_ZERO: + return "XGL_BLEND_ZERO"; + default: + return "Unhandled XGL_BLEND"; + } +} + + +static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) +{ + switch ((XGL_BUFFER_CREATE_FLAGS)input_value) + { + case XGL_BUFFER_CREATE_SHAREABLE_BIT: + return "XGL_BUFFER_CREATE_SHAREABLE_BIT"; + case XGL_BUFFER_CREATE_SPARSE_BIT: + return "XGL_BUFFER_CREATE_SPARSE_BIT"; + default: + return "Unhandled XGL_BUFFER_CREATE_FLAGS"; + } +} + + +static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) +{ + switch ((XGL_FACE_ORIENTATION)input_value) + { + case XGL_FRONT_FACE_CCW: + return "XGL_FRONT_FACE_CCW"; + case XGL_FRONT_FACE_CW: + return "XGL_FRONT_FACE_CW"; + default: + return "Unhandled XGL_FACE_ORIENTATION"; + } +} + + +static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) +{ + switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value) + { + case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT: + return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT"; + case XGL_MEMORY_OUTPUT_COPY_BIT: + return "XGL_MEMORY_OUTPUT_COPY_BIT"; + case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT: + return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT"; + case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT: + return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT"; + case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT: + return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT"; + default: + return "Unhandled XGL_MEMORY_OUTPUT_FLAGS"; + } +} + + +static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) +{ + switch ((XGL_IMAGE_TYPE)input_value) + { + case XGL_IMAGE_1D: + return "XGL_IMAGE_1D"; + case XGL_IMAGE_2D: + return "XGL_IMAGE_2D"; + case XGL_IMAGE_3D: + return "XGL_IMAGE_3D"; + default: + return "Unhandled XGL_IMAGE_TYPE"; + } +} + + +static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) +{ + switch ((XGL_MEMORY_TYPE)input_value) + { + case XGL_MEMORY_TYPE_BUFFER: + return "XGL_MEMORY_TYPE_BUFFER"; + case XGL_MEMORY_TYPE_IMAGE: + return "XGL_MEMORY_TYPE_IMAGE"; + case XGL_MEMORY_TYPE_OTHER: + return "XGL_MEMORY_TYPE_OTHER"; + default: + return "Unhandled XGL_MEMORY_TYPE"; + } +} + + +static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value) +{ + switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value) + { + case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT: + return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT"; + case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT: + return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT"; + case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT: + return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT"; + case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT: + return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT"; + default: + return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS"; + } +} + + +static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) +{ + switch ((XGL_BLEND_FUNC)input_value) + { + case XGL_BLEND_FUNC_ADD: + return "XGL_BLEND_FUNC_ADD"; + case XGL_BLEND_FUNC_MAX: + return "XGL_BLEND_FUNC_MAX"; + case XGL_BLEND_FUNC_MIN: + return "XGL_BLEND_FUNC_MIN"; + case XGL_BLEND_FUNC_REVERSE_SUBTRACT: + return "XGL_BLEND_FUNC_REVERSE_SUBTRACT"; + case XGL_BLEND_FUNC_SUBTRACT: + return "XGL_BLEND_FUNC_SUBTRACT"; + default: + return "Unhandled XGL_BLEND_FUNC"; + } +} + + +static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value) +{ + switch ((XGL_FILL_MODE)input_value) + { + case XGL_FILL_POINTS: + return "XGL_FILL_POINTS"; + case XGL_FILL_SOLID: + return "XGL_FILL_SOLID"; + case XGL_FILL_WIREFRAME: + return "XGL_FILL_WIREFRAME"; + default: + return "Unhandled XGL_FILL_MODE"; + } +} + + +static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) +{ + switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) + { + case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC: + return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC"; + case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: + return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT"; + default: + return "Unhandled XGL_DESCRIPTOR_REGION_USAGE"; + } +} + + +static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) +{ + switch ((XGL_QUERY_CONTROL_FLAGS)input_value) + { + case XGL_QUERY_IMPRECISE_DATA_BIT: + return "XGL_QUERY_IMPRECISE_DATA_BIT"; + default: + return "Unhandled XGL_QUERY_CONTROL_FLAGS"; + } +} + + +static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) +{ + switch ((XGL_QUEUE_TYPE)input_value) + { + case XGL_QUEUE_TYPE_COMPUTE: + return "XGL_QUEUE_TYPE_COMPUTE"; + case XGL_QUEUE_TYPE_DMA: + return "XGL_QUEUE_TYPE_DMA"; + case XGL_QUEUE_TYPE_GRAPHICS: + return "XGL_QUEUE_TYPE_GRAPHICS"; + default: + return "Unhandled XGL_QUEUE_TYPE"; + } +} + + +static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) +{ + switch ((XGL_DESCRIPTOR_TYPE)input_value) + { + case XGL_DESCRIPTOR_TYPE_IMAGE: + return "XGL_DESCRIPTOR_TYPE_IMAGE"; + case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_RAW_BUFFER: + return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER"; + case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC"; + case XGL_DESCRIPTOR_TYPE_SAMPLER: + return "XGL_DESCRIPTOR_TYPE_SAMPLER"; + case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE: + return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE"; + case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC"; + case XGL_DESCRIPTOR_TYPE_TEXTURE: + return "XGL_DESCRIPTOR_TYPE_TEXTURE"; + case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER"; + case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"; + default: + return "Unhandled XGL_DESCRIPTOR_TYPE"; + } +} + + +static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) +{ + switch ((XGL_TEX_FILTER)input_value) + { + case XGL_TEX_FILTER_LINEAR: + return "XGL_TEX_FILTER_LINEAR"; + case XGL_TEX_FILTER_NEAREST: + return "XGL_TEX_FILTER_NEAREST"; + default: + return "Unhandled XGL_TEX_FILTER"; + } +} + + +static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value) +{ + switch ((XGL_SET_EVENT)input_value) + { + case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE: + return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE"; + case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE: + return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE"; + case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE: + return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE"; + case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE: + return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE"; + case XGL_SET_EVENT_TOP_OF_PIPE: + return "XGL_SET_EVENT_TOP_OF_PIPE"; case XGL_SET_EVENT_TRANSFER_COMPLETE: return "XGL_SET_EVENT_TRANSFER_COMPLETE"; case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE: return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE"; default: - return "Unhandled XGL_SET_EVENT"; + 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_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) +static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) { - switch ((XGL_PIPELINE_BIND_POINT)input_value) + switch ((XGL_PIPELINE_SHADER_STAGE)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_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_BIND_POINT"; + return "Unhandled XGL_PIPELINE_SHADER_STAGE"; } } -static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) +static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) { - switch ((XGL_COMPARE_FUNC)input_value) + switch ((XGL_CHANNEL_SWIZZLE)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_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_COMPARE_FUNC"; + return "Unhandled XGL_CHANNEL_SWIZZLE"; } } -static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) +static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) { - switch ((XGL_IMAGE_FORMAT_CLASS)input_value) + switch ((XGL_INDEX_TYPE)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_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_IMAGE_FORMAT_CLASS"; + return "Unhandled XGL_INDEX_TYPE"; } } -static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value) +static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) { - switch ((XGL_FILL_MODE)input_value) + switch ((XGL_ATTACHMENT_LOAD_OP)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_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_FILL_MODE"; + return "Unhandled XGL_ATTACHMENT_LOAD_OP"; } } -static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) +static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) { - switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value) + switch ((XGL_BORDER_COLOR_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_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_MEMORY_PROPERTY_FLAGS"; + 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"; } } @@ -1631,160 +1683,172 @@ static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value) } -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_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) +static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) { - switch ((XGL_IMAGE_TYPE)input_value) + switch ((XGL_TEX_MIPMAP_MODE)input_value) { - case XGL_IMAGE_1D: - return "XGL_IMAGE_1D"; - case XGL_IMAGE_2D: - return "XGL_IMAGE_2D"; - case XGL_IMAGE_3D: - return "XGL_IMAGE_3D"; + case XGL_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_IMAGE_TYPE"; + return "Unhandled XGL_TEX_MIPMAP_MODE"; } } -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"; +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_ATTACHMENT_LOAD_OP"; + return "Unhandled XGL_QUEUE_FLAGS"; } } -static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) +static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) { - switch ((XGL_CHANNEL_SWIZZLE)input_value) + switch ((XGL_LOGIC_OP)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_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_CHANNEL_SWIZZLE"; + return "Unhandled XGL_LOGIC_OP"; } } -static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) +static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) { - switch ((XGL_SHADER_STAGE_FLAGS)input_value) + switch ((XGL_VALIDATION_LEVEL)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_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_SHADER_STAGE_FLAGS"; + return "Unhandled XGL_VALIDATION_LEVEL"; } } -static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) +static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value) { - switch ((XGL_IMAGE_ASPECT)input_value) + switch ((XGL_IMAGE_USAGE_FLAGS)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_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_ASPECT"; + return "Unhandled XGL_IMAGE_USAGE_FLAGS"; } } -static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value) +static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) { - switch ((XGL_BUFFER_USAGE_FLAGS)input_value) + switch ((XGL_SYSTEM_ALLOC_TYPE)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_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_BUFFER_USAGE_FLAGS"; + return "Unhandled XGL_SYSTEM_ALLOC_TYPE"; } } -static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) +static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) { - switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) + switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) { - case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: - return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT"; + case XGL_GPU_COMPAT_ASIC_FEATURES_BIT: + return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT"; + case XGL_GPU_COMPAT_IQ_MATCH_BIT: + return "XGL_GPU_COMPAT_IQ_MATCH_BIT"; + case XGL_GPU_COMPAT_PEER_TRANSFER_BIT: + return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT"; + case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT: + return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT"; + case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT: + return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT"; + case XGL_GPU_COMPAT_SHARED_MEMORY_BIT: + return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT"; + case XGL_GPU_COMPAT_SHARED_SYNC_BIT: + return "XGL_GPU_COMPAT_SHARED_SYNC_BIT"; default: - return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS"; + return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS"; } } @@ -1816,67 +1880,3 @@ static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS i } } - -static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) -{ - switch ((XGL_INDEX_TYPE)input_value) - { - case XGL_INDEX_16: - return "XGL_INDEX_16"; - case XGL_INDEX_32: - return "XGL_INDEX_32"; - case XGL_INDEX_8: - return "XGL_INDEX_8"; - default: - return "Unhandled XGL_INDEX_TYPE"; - } -} - - -static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value) -{ - switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value) - { - case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT: - return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT"; - case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT: - return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT"; - case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT: - return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT"; - case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT: - return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT"; - default: - return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS"; - } -} - - -static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value) -{ - switch ((XGL_FORMAT_FEATURE_FLAGS)input_value) - { - case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT: - return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT"; - case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT: - return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT"; - case XGL_FORMAT_CONVERSION_BIT: - return "XGL_FORMAT_CONVERSION_BIT"; - case XGL_FORMAT_DEPTH_ATTACHMENT_BIT: - return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT"; - case XGL_FORMAT_IMAGE_COPY_BIT: - return "XGL_FORMAT_IMAGE_COPY_BIT"; - case XGL_FORMAT_IMAGE_SHADER_READ_BIT: - return "XGL_FORMAT_IMAGE_SHADER_READ_BIT"; - case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT: - return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT"; - case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT: - return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT"; - case XGL_FORMAT_MSAA_ATTACHMENT_BIT: - return "XGL_FORMAT_MSAA_ATTACHMENT_BIT"; - case XGL_FORMAT_STENCIL_ATTACHMENT_BIT: - return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT"; - default: - return "Unhandled XGL_FORMAT_FEATURE_FLAGS"; - } -} - diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h index b45590b..e80a1d1 100644 --- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h +++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h @@ -3,51 +3,12 @@ #include -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_BLEND_FUNC(XGL_BLEND_FUNC input_value) -{ - switch ((XGL_BLEND_FUNC)input_value) - { - case XGL_BLEND_FUNC_ADD: - case XGL_BLEND_FUNC_MAX: - case XGL_BLEND_FUNC_MIN: - case XGL_BLEND_FUNC_REVERSE_SUBTRACT: - case XGL_BLEND_FUNC_SUBTRACT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) +static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) { - switch ((XGL_MEMORY_REF_FLAGS)input_value) + switch ((XGL_DEPTH_MODE)input_value) { - case XGL_MEMORY_REF_READ_ONLY_BIT: + case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: + case XGL_DEPTH_MODE_ZERO_TO_ONE: return 1; default: return 0; @@ -70,105 +31,12 @@ static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_va } -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_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_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_LOGIC_OP(XGL_LOGIC_OP input_value) -{ - switch ((XGL_LOGIC_OP)input_value) - { - case XGL_LOGIC_OP_AND: - case XGL_LOGIC_OP_AND_INVERTED: - case XGL_LOGIC_OP_AND_REVERSE: - case XGL_LOGIC_OP_CLEAR: - case XGL_LOGIC_OP_COPY: - case XGL_LOGIC_OP_COPY_INVERTED: - case XGL_LOGIC_OP_EQUIV: - case XGL_LOGIC_OP_INVERT: - case XGL_LOGIC_OP_NAND: - case XGL_LOGIC_OP_NOOP: - case XGL_LOGIC_OP_NOR: - case XGL_LOGIC_OP_OR: - case XGL_LOGIC_OP_OR_INVERTED: - case XGL_LOGIC_OP_OR_REVERSE: - case XGL_LOGIC_OP_SET: - case XGL_LOGIC_OP_XOR: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) -{ - switch ((XGL_DESCRIPTOR_TYPE)input_value) - { - case XGL_DESCRIPTOR_TYPE_IMAGE: - case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER: - case XGL_DESCRIPTOR_TYPE_RAW_BUFFER: - case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC: - case XGL_DESCRIPTOR_TYPE_SAMPLER: - case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE: - case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER: - case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC: - case XGL_DESCRIPTOR_TYPE_TEXTURE: - case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER: - case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) +static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) { - switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) + switch ((XGL_PIPELINE_BIND_POINT)input_value) { - case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: + case XGL_PIPELINE_BIND_POINT_COMPUTE: + case XGL_PIPELINE_BIND_POINT_GRAPHICS: return 1; default: return 0; @@ -176,13 +44,11 @@ static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_T } -static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) +static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) { - switch ((XGL_MEMORY_TYPE)input_value) + switch ((XGL_MEMORY_REF_FLAGS)input_value) { - case XGL_MEMORY_TYPE_BUFFER: - case XGL_MEMORY_TYPE_IMAGE: - case XGL_MEMORY_TYPE_OTHER: + case XGL_MEMORY_REF_READ_ONLY_BIT: return 1; default: return 0; @@ -190,16 +56,11 @@ static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) } -static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) +static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) { - switch ((XGL_MEMORY_PRIORITY)input_value) + switch ((XGL_PIPELINE_CREATE_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_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: return 1; default: return 0; @@ -221,12 +82,12 @@ static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP } -static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) +static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) { - switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value) + switch ((XGL_QUERY_TYPE)input_value) { - case XGL_DESCRIPTOR_UDPATE_MODE_COPY: - case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST: + case XGL_QUERY_OCCLUSION: + case XGL_QUERY_PIPELINE_STATISTICS: return 1; default: return 0; @@ -248,13 +109,12 @@ static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP } -static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) +static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) { - switch ((XGL_QUEUE_TYPE)input_value) + switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) { - case XGL_QUEUE_TYPE_COMPUTE: - case XGL_QUEUE_TYPE_DMA: - case XGL_QUEUE_TYPE_GRAPHICS: + case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT: + case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT: return 1; default: return 0; @@ -262,15 +122,12 @@ static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) } -static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) +static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) { - switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) + switch ((XGL_TIMESTAMP_TYPE)input_value) { - case XGL_SYSTEM_ALLOC_API_OBJECT: - case XGL_SYSTEM_ALLOC_DEBUG: - case XGL_SYSTEM_ALLOC_INTERNAL: - case XGL_SYSTEM_ALLOC_INTERNAL_SHADER: - case XGL_SYSTEM_ALLOC_INTERNAL_TEMP: + case XGL_TIMESTAMP_BOTTOM: + case XGL_TIMESTAMP_TOP: return 1; default: return 0; @@ -278,12 +135,12 @@ static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE inpu } -static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) +static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) { - switch ((XGL_DEPTH_MODE)input_value) + switch ((XGL_IMAGE_TILING)input_value) { - case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: - case XGL_DEPTH_MODE_ZERO_TO_ONE: + case XGL_LINEAR_TILING: + case XGL_OPTIMAL_TILING: return 1; default: return 0; @@ -291,12 +148,13 @@ static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) } -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) { - switch ((XGL_IMAGE_TILING)input_value) + switch ((XGL_IMAGE_ASPECT)input_value) { - case XGL_LINEAR_TILING: - case XGL_OPTIMAL_TILING: + case XGL_IMAGE_ASPECT_COLOR: + case XGL_IMAGE_ASPECT_DEPTH: + case XGL_IMAGE_ASPECT_STENCIL: return 1; default: return 0; @@ -304,20 +162,12 @@ static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) } -static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) { - switch ((XGL_IMAGE_USAGE_FLAGS)input_value) + switch ((XGL_DESCRIPTOR_UPDATE_MODE)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_DESCRIPTOR_UDPATE_MODE_COPY: + case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST: return 1; default: return 0; @@ -325,14 +175,11 @@ static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS inpu } -static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) +static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) { - switch ((XGL_PHYSICAL_GPU_TYPE)input_value) + switch ((XGL_SEMAPHORE_CREATE_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_SEMAPHORE_CREATE_SHAREABLE_BIT: return 1; default: return 0; @@ -340,18 +187,14 @@ static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE inpu } -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) { - switch ((XGL_STENCIL_OP)input_value) + switch ((XGL_PHYSICAL_GPU_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_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; @@ -359,85 +202,24 @@ static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) } -static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) +static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS 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_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) -{ - switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) - { - case XGL_GPU_COMPAT_ASIC_FEATURES_BIT: - case XGL_GPU_COMPAT_IQ_MATCH_BIT: - case XGL_GPU_COMPAT_PEER_TRANSFER_BIT: - case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT: - case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT: - case XGL_GPU_COMPAT_SHARED_MEMORY_BIT: - case XGL_GPU_COMPAT_SHARED_SYNC_BIT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) -{ - switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) - { - case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value) -{ - switch ((XGL_DEVICE_CREATE_FLAGS)input_value) - { - case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT: - case XGL_DEVICE_CREATE_VALIDATION_BIT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) -{ - switch ((XGL_OBJECT_INFO_TYPE)input_value) - { - case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS: - case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS: - case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT: - case XGL_INFO_TYPE_MEMORY_REQUIREMENTS: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) -{ - switch ((XGL_TEX_MIPMAP_MODE)input_value) + switch ((XGL_BUFFER_USAGE_FLAGS)input_value) { - case XGL_TEX_MIPMAP_BASE: - case XGL_TEX_MIPMAP_LINEAR: - case XGL_TEX_MIPMAP_NEAREST: + case XGL_BUFFER_USAGE_GENERAL: + case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT: + case XGL_BUFFER_USAGE_INDEX_FETCH_BIT: + case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT: + case XGL_BUFFER_USAGE_RAW_BUFFER_BIT: + case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT: + case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT: + case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT: + case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT: + case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT: + case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT: + case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT: + case XGL_BUFFER_USAGE_UNIFORM_READ_BIT: + case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT: return 1; default: return 0; @@ -511,12 +293,235 @@ static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_valu } -static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) +static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value) { - switch ((XGL_TIMESTAMP_TYPE)input_value) + switch ((XGL_STATE_BIND_POINT)input_value) { - case XGL_TIMESTAMP_BOTTOM: - case XGL_TIMESTAMP_TOP: + 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) +{ + switch ((XGL_DESCRIPTOR_SET_USAGE)input_value) + { + case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT: + case XGL_DESCRIPTOR_SET_USAGE_STATIC: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) +{ + switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) + { + case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) +{ + switch ((XGL_STENCIL_OP)input_value) + { + case XGL_STENCIL_OP_DEC_CLAMP: + case XGL_STENCIL_OP_DEC_WRAP: + case XGL_STENCIL_OP_INC_CLAMP: + case XGL_STENCIL_OP_INC_WRAP: + case XGL_STENCIL_OP_INVERT: + case XGL_STENCIL_OP_KEEP: + case XGL_STENCIL_OP_REPLACE: + case XGL_STENCIL_OP_ZERO: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value) +{ + switch ((XGL_BUFFER_VIEW_TYPE)input_value) + { + case XGL_BUFFER_VIEW_RAW: + case XGL_BUFFER_VIEW_STRUCTURED: + case XGL_BUFFER_VIEW_TYPED: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) +{ + switch ((XGL_PHYSICAL_GPU_TYPE)input_value) + { + case XGL_GPU_TYPE_DISCRETE: + case XGL_GPU_TYPE_INTEGRATED: + case XGL_GPU_TYPE_OTHER: + case XGL_GPU_TYPE_VIRTUAL: return 1; default: return 0; @@ -537,14 +542,20 @@ static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VE } -static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) +static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value) { - switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value) + switch ((XGL_FORMAT_FEATURE_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_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; @@ -552,12 +563,47 @@ static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO } -static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) +static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) { - switch ((XGL_TEX_FILTER)input_value) + switch ((XGL_COORDINATE_ORIGIN)input_value) { - case XGL_TEX_FILTER_LINEAR: - case XGL_TEX_FILTER_NEAREST: + case XGL_COORDINATE_ORIGIN_LOWER_LEFT: + case XGL_COORDINATE_ORIGIN_UPPER_LEFT: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) +{ + switch ((XGL_MEMORY_PRIORITY)input_value) + { + case XGL_MEMORY_PRIORITY_HIGH: + case XGL_MEMORY_PRIORITY_LOW: + case XGL_MEMORY_PRIORITY_NORMAL: + case XGL_MEMORY_PRIORITY_UNUSED: + case XGL_MEMORY_PRIORITY_VERY_HIGH: + case XGL_MEMORY_PRIORITY_VERY_LOW: + return 1; + default: + return 0; + } +} + + +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; @@ -595,12 +641,55 @@ static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value) } -static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE 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_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) +{ + switch ((XGL_FACE_ORIENTATION)input_value) + { + case XGL_FRONT_FACE_CCW: + case XGL_FRONT_FACE_CW: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) +{ + switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value) + { + case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT: + case XGL_MEMORY_OUTPUT_COPY_BIT: + case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT: + case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT: + case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) { - switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) + switch ((XGL_IMAGE_TYPE)input_value) { - case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC: - case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: + case XGL_IMAGE_1D: + case XGL_IMAGE_2D: + case XGL_IMAGE_3D: return 1; default: return 0; @@ -608,14 +697,13 @@ static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGIO } -static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value) +static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) { - switch ((XGL_CULL_MODE)input_value) + switch ((XGL_MEMORY_TYPE)input_value) { - case XGL_CULL_BACK: - case XGL_CULL_FRONT: - case XGL_CULL_FRONT_AND_BACK: - case XGL_CULL_NONE: + case XGL_MEMORY_TYPE_BUFFER: + case XGL_MEMORY_TYPE_IMAGE: + case XGL_MEMORY_TYPE_OTHER: return 1; default: return 0; @@ -623,13 +711,14 @@ static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value) } -static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value) +static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value) { - switch ((XGL_BUFFER_VIEW_TYPE)input_value) + switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value) { - case XGL_BUFFER_VIEW_RAW: - case XGL_BUFFER_VIEW_STRUCTURED: - case XGL_BUFFER_VIEW_TYPED: + 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; @@ -637,50 +726,15 @@ static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_ } -static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value) +static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) { - switch ((XGL_RESULT)input_value) + switch ((XGL_BLEND_FUNC)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_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; @@ -688,15 +742,13 @@ static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value) } -static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value) { - switch ((XGL_IMAGE_CREATE_FLAGS)input_value) + switch ((XGL_FILL_MODE)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_FILL_POINTS: + case XGL_FILL_SOLID: + case XGL_FILL_WIREFRAME: return 1; default: return 0; @@ -704,15 +756,12 @@ static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS in } -static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) { - switch ((XGL_TEX_ADDRESS)input_value) + switch ((XGL_DESCRIPTOR_REGION_USAGE)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_DESCRIPTOR_REGION_USAGE_DYNAMIC: + case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: return 1; default: return 0; @@ -720,14 +769,11 @@ 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) +static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) { - switch ((XGL_QUEUE_FLAGS)input_value) + switch ((XGL_QUERY_CONTROL_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_QUERY_IMPRECISE_DATA_BIT: return 1; default: return 0; @@ -735,12 +781,13 @@ static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) } -static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) +static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) { - switch ((XGL_QUERY_TYPE)input_value) + switch ((XGL_QUEUE_TYPE)input_value) { - case XGL_QUERY_OCCLUSION: - case XGL_QUERY_PIPELINE_STATISTICS: + case XGL_QUEUE_TYPE_COMPUTE: + case XGL_QUEUE_TYPE_DMA: + case XGL_QUEUE_TYPE_GRAPHICS: return 1; default: return 0; @@ -748,18 +795,22 @@ static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) } -static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) { - switch ((XGL_IMAGE_LAYOUT)input_value) + switch ((XGL_DESCRIPTOR_TYPE)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_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; @@ -767,11 +818,12 @@ static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) } -static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) +static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) { - switch ((XGL_QUERY_CONTROL_FLAGS)input_value) + switch ((XGL_TEX_FILTER)input_value) { - case XGL_QUERY_IMPRECISE_DATA_BIT: + case XGL_TEX_FILTER_LINEAR: + case XGL_TEX_FILTER_NEAREST: return 1; default: return 0; @@ -779,11 +831,17 @@ static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS } -static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) +static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value) { - switch ((XGL_FORMAT_INFO_TYPE)input_value) + switch ((XGL_SET_EVENT)input_value) { - case XGL_INFO_TYPE_FORMAT_PROPERTIES: + 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; @@ -791,16 +849,15 @@ static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_ } -static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) +static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) { - switch ((XGL_PIPELINE_SHADER_STAGE)input_value) + switch ((XGL_IMAGE_CREATE_FLAGS)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_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; @@ -808,12 +865,18 @@ static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_ST } -static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) +static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) { - switch ((XGL_COORDINATE_ORIGIN)input_value) + switch ((XGL_COMPARE_FUNC)input_value) { - case XGL_COORDINATE_ORIGIN_LOWER_LEFT: - case XGL_COORDINATE_ORIGIN_UPPER_LEFT: + 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; @@ -821,15 +884,18 @@ static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN inpu } -static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) +static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) { - switch ((XGL_VALIDATION_LEVEL)input_value) + switch ((XGL_IMAGE_LAYOUT)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_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; @@ -837,12 +903,17 @@ static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_ } -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_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) { - switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) + switch ((XGL_SHADER_STAGE_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_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; @@ -850,12 +921,16 @@ static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_ST } -static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) +static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) { - switch ((XGL_WAIT_EVENT)input_value) + switch ((XGL_PIPELINE_SHADER_STAGE)input_value) { - case XGL_WAIT_EVENT_BEFORE_RASTERIZATION: - case XGL_WAIT_EVENT_TOP_OF_PIPE: + 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; @@ -863,12 +938,16 @@ static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) } -static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) { - switch ((XGL_BUFFER_CREATE_FLAGS)input_value) + switch ((XGL_CHANNEL_SWIZZLE)input_value) { - case XGL_BUFFER_CREATE_SHAREABLE_BIT: - case XGL_BUFFER_CREATE_SPARSE_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; @@ -876,17 +955,13 @@ static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS } -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: +static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) +{ + switch ((XGL_INDEX_TYPE)input_value) + { + case XGL_INDEX_16: + case XGL_INDEX_32: + case XGL_INDEX_8: return 1; default: return 0; @@ -894,12 +969,13 @@ static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value) } -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; @@ -907,18 +983,13 @@ static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT } -static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) +static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) { - switch ((XGL_COMPARE_FUNC)input_value) + switch ((XGL_BORDER_COLOR_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_BORDER_COLOR_OPAQUE_BLACK: + case XGL_BORDER_COLOR_OPAQUE_WHITE: + case XGL_BORDER_COLOR_TRANSPARENT_BLACK: return 1; default: return 0; @@ -926,28 +997,14 @@ static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) } -static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) +static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value) { - switch ((XGL_IMAGE_FORMAT_CLASS)input_value) + switch ((XGL_CULL_MODE)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_CULL_BACK: + case XGL_CULL_FRONT: + case XGL_CULL_FRONT_AND_BACK: + case XGL_CULL_NONE: return 1; default: return 0; @@ -955,13 +1012,12 @@ static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS in } -static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value) +static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value) { - switch ((XGL_FILL_MODE)input_value) + switch ((XGL_DEVICE_CREATE_FLAGS)input_value) { - case XGL_FILL_POINTS: - case XGL_FILL_SOLID: - case XGL_FILL_WIREFRAME: + case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT: + case XGL_DEVICE_CREATE_VALIDATION_BIT: return 1; default: return 0; @@ -969,17 +1025,11 @@ static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value) } -static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) +static inline uint32_t validate_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: - 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_INFO_TYPE_FORMAT_PROPERTIES: return 1; default: return 0; @@ -1165,26 +1215,13 @@ static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value) } -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_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) +static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) { - switch ((XGL_IMAGE_TYPE)input_value) + switch ((XGL_TEX_MIPMAP_MODE)input_value) { - case XGL_IMAGE_1D: - case XGL_IMAGE_2D: - case XGL_IMAGE_3D: + case XGL_TEX_MIPMAP_BASE: + case XGL_TEX_MIPMAP_LINEAR: + case XGL_TEX_MIPMAP_NEAREST: return 1; default: return 0; @@ -1192,13 +1229,14 @@ static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) } -static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) +static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) { - switch ((XGL_ATTACHMENT_LOAD_OP)input_value) + switch ((XGL_QUEUE_FLAGS)input_value) { - case XGL_ATTACHMENT_LOAD_OP_CLEAR: - case XGL_ATTACHMENT_LOAD_OP_DONT_CARE: - case XGL_ATTACHMENT_LOAD_OP_LOAD: + 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; @@ -1206,16 +1244,26 @@ static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP in } -static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) +static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) { - switch ((XGL_CHANNEL_SWIZZLE)input_value) + switch ((XGL_LOGIC_OP)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_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; @@ -1223,17 +1271,15 @@ static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_va } -static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) +static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) { - switch ((XGL_SHADER_STAGE_FLAGS)input_value) + switch ((XGL_VALIDATION_LEVEL)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_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; @@ -1241,13 +1287,20 @@ static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS in } -static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) +static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value) { - switch ((XGL_IMAGE_ASPECT)input_value) + switch ((XGL_IMAGE_USAGE_FLAGS)input_value) { - case XGL_IMAGE_ASPECT_COLOR: - case XGL_IMAGE_ASPECT_DEPTH: - case XGL_IMAGE_ASPECT_STENCIL: + 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; @@ -1255,24 +1308,15 @@ static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) } -static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value) +static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) { - switch ((XGL_BUFFER_USAGE_FLAGS)input_value) + switch ((XGL_SYSTEM_ALLOC_TYPE)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_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; @@ -1280,11 +1324,17 @@ static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS in } -static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) { - switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) + switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) { - case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: + case XGL_GPU_COMPAT_ASIC_FEATURES_BIT: + case XGL_GPU_COMPAT_IQ_MATCH_BIT: + case XGL_GPU_COMPAT_PEER_TRANSFER_BIT: + case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT: + case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT: + case XGL_GPU_COMPAT_SHARED_MEMORY_BIT: + case XGL_GPU_COMPAT_SHARED_SYNC_BIT: return 1; default: return 0; @@ -1311,53 +1361,3 @@ static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS in } } - -static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) -{ - switch ((XGL_INDEX_TYPE)input_value) - { - case XGL_INDEX_16: - case XGL_INDEX_32: - case XGL_INDEX_8: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value) -{ - switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value) - { - case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT: - case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT: - case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT: - case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value) -{ - switch ((XGL_FORMAT_FEATURE_FLAGS)input_value) - { - case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT: - case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT: - case XGL_FORMAT_CONVERSION_BIT: - case XGL_FORMAT_DEPTH_ATTACHMENT_BIT: - case XGL_FORMAT_IMAGE_COPY_BIT: - case XGL_FORMAT_IMAGE_SHADER_READ_BIT: - case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT: - case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT: - case XGL_FORMAT_MSAA_ATTACHMENT_BIT: - case XGL_FORMAT_STENCIL_ATTACHMENT_BIT: - return 1; - default: - return 0; - } -} - diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp index c05acdd..c3c1cdb 100644 --- a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp +++ b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp @@ -27,7 +27,7 @@ extern "C" { -#include "glvtrace_xgl_packet_id.h" +#include "glv_vk_packet_id.h" } ApiReplay* g_pReplayer = NULL; diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt index 5de203d..7cc11d7 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt @@ -11,26 +11,26 @@ file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen) add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl.c - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext.c - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg.c - ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h + ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_struct_size_helper.h ${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-trace-h > glvtrace_xgl_xgl.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-trace-c > glvtrace_xgl_xgl.c - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-h > glvtrace_xgl_xglwsix11ext.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-c > glvtrace_xgl_xglwsix11ext.c - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-h > glvtrace_xgl_xgldbg.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-c > glvtrace_xgl_xgldbg.c - COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h + COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_struct_wrappers ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen DEPENDS ${SRC_DIR}/../../../xgl_helper.py @@ -48,13 +48,13 @@ set(SRC_LIST set_source_files_properties( ${SRC_LIST} PROPERTIES LANGUAGE C) set (HDR_LIST - codegen/glvtrace_xgl_packet_id.h + codegen/glv_vk_packet_id.h codegen/glvtrace_xgl_xgl.h - codegen/glvtrace_xgl_xgl_structs.h + codegen/glv_vk_vk_structs.h codegen/glvtrace_xgl_xgldbg.h - codegen/glvtrace_xgl_xgldbg_structs.h + codegen/glv_vk_vkdbg_structs.h codegen/glvtrace_xgl_xglwsix11ext.h - codegen/glvtrace_xgl_xglwsix11ext_structs.h + codegen/glv_vk_vkwsix11ext_structs.h codegen/xgl_struct_size_helper.h codegen/xgl_enum_string_helper.h ) diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h similarity index 99% rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h index d1dded3..d774f98 100644 --- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h @@ -29,9 +29,9 @@ #include "glv_trace_packet_utils.h" #include "glv_trace_packet_identifiers.h" #include "glv_interconnect.h" -#include "glvtrace_xgl_xgl_structs.h" -#include "glvtrace_xgl_xgldbg_structs.h" -#include "glvtrace_xgl_xglwsix11ext_structs.h" +#include "glv_vk_vk_structs.h" +#include "glv_vk_vkdbg_structs.h" +#include "glv_vk_vkwsix11ext_structs.h" #include "xgl_enum_string_helper.h" #if defined(WIN32) #define snprintf _snprintf diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vk_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgl_structs.h rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vk_structs.h diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkdbg_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgldbg_structs.h rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkdbg_structs.h diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkwsix11ext_structs.h similarity index 100% rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkwsix11ext_structs.h diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h index 6284559..4de693d 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h @@ -24,8 +24,8 @@ * DEALINGS IN THE SOFTWARE. */ -#include "glvtrace_xgl_xgl_structs.h" -#include "glvtrace_xgl_packet_id.h" +#include "glv_vk_vk_structs.h" +#include "glv_vk_packet_id.h" void AttachHooks(); void DetachHooks(); diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c index a298093..c0e9cc7 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c @@ -28,8 +28,8 @@ #include "glv_common.h" #include "glvtrace_xgl_xgl.h" #include "glvtrace_xgl_xgldbg.h" -#include "glvtrace_xgl_xgldbg_structs.h" -#include "glvtrace_xgl_packet_id.h" +#include "glv_vk_vkdbg_structs.h" +#include "glv_vk_packet_id.h" #ifdef WIN32 #include "mhook/mhook-lib/mhook.h" #endif diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c index 8328257..4a8da11 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c @@ -27,8 +27,8 @@ #include "glv_platform.h" #include "glv_common.h" #include "glvtrace_xgl_xglwsix11ext.h" -#include "glvtrace_xgl_xglwsix11ext_structs.h" -#include "glvtrace_xgl_packet_id.h" +#include "glv_vk_vkwsix11ext_structs.h" +#include "glv_vk_packet_id.h" #ifdef WIN32 #include "mhook/mhook-lib/mhook.h" #endif diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h index b3a9606..a81bb7b 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h @@ -3,64 +3,6 @@ #include -static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) -{ - switch ((XGL_STENCIL_OP)input_value) - { - case XGL_STENCIL_OP_DEC_CLAMP: - return "XGL_STENCIL_OP_DEC_CLAMP"; - case XGL_STENCIL_OP_DEC_WRAP: - return "XGL_STENCIL_OP_DEC_WRAP"; - case XGL_STENCIL_OP_INC_CLAMP: - return "XGL_STENCIL_OP_INC_CLAMP"; - case XGL_STENCIL_OP_INC_WRAP: - return "XGL_STENCIL_OP_INC_WRAP"; - case XGL_STENCIL_OP_INVERT: - return "XGL_STENCIL_OP_INVERT"; - case XGL_STENCIL_OP_KEEP: - return "XGL_STENCIL_OP_KEEP"; - case XGL_STENCIL_OP_REPLACE: - return "XGL_STENCIL_OP_REPLACE"; - case XGL_STENCIL_OP_ZERO: - return "XGL_STENCIL_OP_ZERO"; - default: - return "Unhandled XGL_STENCIL_OP"; - } -} - - -static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) -{ - switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) - { - case XGL_SYSTEM_ALLOC_API_OBJECT: - return "XGL_SYSTEM_ALLOC_API_OBJECT"; - case XGL_SYSTEM_ALLOC_DEBUG: - return "XGL_SYSTEM_ALLOC_DEBUG"; - case XGL_SYSTEM_ALLOC_INTERNAL: - return "XGL_SYSTEM_ALLOC_INTERNAL"; - case XGL_SYSTEM_ALLOC_INTERNAL_SHADER: - return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER"; - case XGL_SYSTEM_ALLOC_INTERNAL_TEMP: - return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP"; - default: - return "Unhandled XGL_SYSTEM_ALLOC_TYPE"; - } -} - - -static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) -{ - switch ((XGL_MEMORY_REF_FLAGS)input_value) - { - case XGL_MEMORY_REF_READ_ONLY_BIT: - return "XGL_MEMORY_REF_READ_ONLY_BIT"; - default: - return "Unhandled XGL_MEMORY_REF_FLAGS"; - } -} - - static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) { switch ((XGL_PIPELINE_BIND_POINT)input_value) @@ -75,56 +17,52 @@ static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT } -static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) +static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) { - switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value) + switch ((XGL_PIPELINE_SHADER_STAGE)input_value) { - case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT: - return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT"; - case XGL_MEMORY_OUTPUT_COPY_BIT: - return "XGL_MEMORY_OUTPUT_COPY_BIT"; - case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT: - return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT"; - case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT: - return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT"; - case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT: - return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT"; + case XGL_SHADER_STAGE_COMPUTE: + return "XGL_SHADER_STAGE_COMPUTE"; + case XGL_SHADER_STAGE_FRAGMENT: + return "XGL_SHADER_STAGE_FRAGMENT"; + case XGL_SHADER_STAGE_GEOMETRY: + return "XGL_SHADER_STAGE_GEOMETRY"; + case XGL_SHADER_STAGE_TESS_CONTROL: + return "XGL_SHADER_STAGE_TESS_CONTROL"; + case XGL_SHADER_STAGE_TESS_EVALUATION: + return "XGL_SHADER_STAGE_TESS_EVALUATION"; + case XGL_SHADER_STAGE_VERTEX: + return "XGL_SHADER_STAGE_VERTEX"; default: - return "Unhandled XGL_MEMORY_OUTPUT_FLAGS"; + return "Unhandled XGL_PIPELINE_SHADER_STAGE"; } } -static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value) +static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) { - switch ((XGL_ATTACHMENT_STORE_OP)input_value) + switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) { - case XGL_ATTACHMENT_STORE_OP_DONT_CARE: - return "XGL_ATTACHMENT_STORE_OP_DONT_CARE"; - case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA: - return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA"; - case XGL_ATTACHMENT_STORE_OP_STORE: - return "XGL_ATTACHMENT_STORE_OP_STORE"; + case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: + return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; default: - return "Unhandled XGL_ATTACHMENT_STORE_OP"; + return "Unhandled XGL_PIPELINE_CREATE_FLAGS"; } } -static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) +static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) { - switch ((XGL_OBJECT_INFO_TYPE)input_value) + switch ((XGL_MEMORY_TYPE)input_value) { - case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS: - return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS"; - case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS: - return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS"; - case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT: - return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT"; - case XGL_INFO_TYPE_MEMORY_REQUIREMENTS: - return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS"; + case XGL_MEMORY_TYPE_BUFFER: + return "XGL_MEMORY_TYPE_BUFFER"; + case XGL_MEMORY_TYPE_IMAGE: + return "XGL_MEMORY_TYPE_IMAGE"; + case XGL_MEMORY_TYPE_OTHER: + return "XGL_MEMORY_TYPE_OTHER"; default: - return "Unhandled XGL_OBJECT_INFO_TYPE"; + return "Unhandled XGL_MEMORY_TYPE"; } } @@ -151,957 +89,23 @@ static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_v } -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_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) -{ - switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value) - { - case XGL_DESCRIPTOR_UDPATE_MODE_COPY: - return "XGL_DESCRIPTOR_UDPATE_MODE_COPY"; - case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST: - return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST"; - default: - return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE"; - } -} - - -static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value) -{ - switch ((XGL_IMAGE_USAGE_FLAGS)input_value) - { - case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: - return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"; - case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT: - return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT"; - case XGL_IMAGE_USAGE_GENERAL: - return "XGL_IMAGE_USAGE_GENERAL"; - case XGL_IMAGE_USAGE_IMAGE_BIT: - return "XGL_IMAGE_USAGE_IMAGE_BIT"; - case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT: - return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT"; - case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT: - return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT"; - case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT: - return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT"; - case XGL_IMAGE_USAGE_TEXTURE_BIT: - return "XGL_IMAGE_USAGE_TEXTURE_BIT"; - case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT: - return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT"; - case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT: - return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT"; - default: - return "Unhandled XGL_IMAGE_USAGE_FLAGS"; - } -} - - -static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) -{ - switch ((XGL_IMAGE_FORMAT_CLASS)input_value) - { - case XGL_IMAGE_FORMAT_CLASS_128_BITS: - return "XGL_IMAGE_FORMAT_CLASS_128_BITS"; - case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK: - return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK"; - case XGL_IMAGE_FORMAT_CLASS_16_BITS: - return "XGL_IMAGE_FORMAT_CLASS_16_BITS"; - case XGL_IMAGE_FORMAT_CLASS_24_BITS: - return "XGL_IMAGE_FORMAT_CLASS_24_BITS"; - case XGL_IMAGE_FORMAT_CLASS_32_BITS: - return "XGL_IMAGE_FORMAT_CLASS_32_BITS"; - case XGL_IMAGE_FORMAT_CLASS_48_BITS: - return "XGL_IMAGE_FORMAT_CLASS_48_BITS"; - case XGL_IMAGE_FORMAT_CLASS_64_BITS: - return "XGL_IMAGE_FORMAT_CLASS_64_BITS"; - case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK: - return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK"; - case XGL_IMAGE_FORMAT_CLASS_8_BITS: - return "XGL_IMAGE_FORMAT_CLASS_8_BITS"; - case XGL_IMAGE_FORMAT_CLASS_96_BITS: - return "XGL_IMAGE_FORMAT_CLASS_96_BITS"; - case XGL_IMAGE_FORMAT_CLASS_D16: - return "XGL_IMAGE_FORMAT_CLASS_D16"; - case XGL_IMAGE_FORMAT_CLASS_D16S8: - return "XGL_IMAGE_FORMAT_CLASS_D16S8"; - case XGL_IMAGE_FORMAT_CLASS_D24: - return "XGL_IMAGE_FORMAT_CLASS_D24"; - case XGL_IMAGE_FORMAT_CLASS_D24S8: - return "XGL_IMAGE_FORMAT_CLASS_D24S8"; - case XGL_IMAGE_FORMAT_CLASS_D32: - return "XGL_IMAGE_FORMAT_CLASS_D32"; - case XGL_IMAGE_FORMAT_CLASS_D32S8: - return "XGL_IMAGE_FORMAT_CLASS_D32S8"; - case XGL_IMAGE_FORMAT_CLASS_LINEAR: - return "XGL_IMAGE_FORMAT_CLASS_LINEAR"; - case XGL_IMAGE_FORMAT_CLASS_S8: - return "XGL_IMAGE_FORMAT_CLASS_S8"; - default: - return "Unhandled XGL_IMAGE_FORMAT_CLASS"; - } -} - - -static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) +static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) { - switch ((XGL_QUERY_TYPE)input_value) + switch ((XGL_DEPTH_MODE)input_value) { - case XGL_QUERY_OCCLUSION: - return "XGL_QUERY_OCCLUSION"; - case XGL_QUERY_PIPELINE_STATISTICS: - return "XGL_QUERY_PIPELINE_STATISTICS"; + 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_QUERY_TYPE"; + return "Unhandled XGL_DEPTH_MODE"; } } -static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value) +static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value) { - switch ((XGL_STRUCTURE_TYPE)input_value) - { - case XGL_STRUCTURE_TYPE_APPLICATION_INFO: - return "XGL_STRUCTURE_TYPE_APPLICATION_INFO"; - case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: - return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"; - case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO: - return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO"; - case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO: - return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO"; - case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO: - return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO"; - case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO: - return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO"; - case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: - return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"; - case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO: - return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO"; - case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO: - return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO"; - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO: - return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO"; - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO: - return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO"; - case XGL_STRUCTURE_TYPE_MEMORY_BARRIER: - return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER"; - case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO: - return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO"; - case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO: - return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER: - return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER"; - case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO: - return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO"; - case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO: - return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO"; - case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY: - return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY"; - case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS: - return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS"; - case XGL_STRUCTURE_TYPE_UPDATE_IMAGES: - return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES"; - case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS"; - case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES"; - default: - return "Unhandled XGL_STRUCTURE_TYPE"; - } -} - - -static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) -{ - switch ((XGL_IMAGE_CREATE_FLAGS)input_value) - { - case XGL_IMAGE_CREATE_CLONEABLE_BIT: - return "XGL_IMAGE_CREATE_CLONEABLE_BIT"; - case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT: - return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT"; - case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT: - return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; - case XGL_IMAGE_CREATE_SHAREABLE_BIT: - return "XGL_IMAGE_CREATE_SHAREABLE_BIT"; - case XGL_IMAGE_CREATE_SPARSE_BIT: - return "XGL_IMAGE_CREATE_SPARSE_BIT"; - default: - return "Unhandled XGL_IMAGE_CREATE_FLAGS"; - } -} - - -static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value) -{ - switch ((XGL_MEMORY_INPUT_FLAGS)input_value) - { - case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT: - return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT"; - case XGL_MEMORY_INPUT_COPY_BIT: - return "XGL_MEMORY_INPUT_COPY_BIT"; - case XGL_MEMORY_INPUT_CPU_READ_BIT: - return "XGL_MEMORY_INPUT_CPU_READ_BIT"; - case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT: - return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT"; - case XGL_MEMORY_INPUT_INDEX_FETCH_BIT: - return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT"; - case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT: - return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT"; - case XGL_MEMORY_INPUT_SHADER_READ_BIT: - return "XGL_MEMORY_INPUT_SHADER_READ_BIT"; - case XGL_MEMORY_INPUT_UNIFORM_READ_BIT: - return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT"; - case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT: - return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT"; - default: - return "Unhandled XGL_MEMORY_INPUT_FLAGS"; - } -} - - -static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) -{ - switch ((XGL_IMAGE_ASPECT)input_value) - { - case XGL_IMAGE_ASPECT_COLOR: - return "XGL_IMAGE_ASPECT_COLOR"; - case XGL_IMAGE_ASPECT_DEPTH: - return "XGL_IMAGE_ASPECT_DEPTH"; - case XGL_IMAGE_ASPECT_STENCIL: - return "XGL_IMAGE_ASPECT_STENCIL"; - default: - return "Unhandled XGL_IMAGE_ASPECT"; - } -} - - -static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value) -{ - switch ((XGL_DEVICE_CREATE_FLAGS)input_value) - { - case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT: - return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT"; - case XGL_DEVICE_CREATE_VALIDATION_BIT: - return "XGL_DEVICE_CREATE_VALIDATION_BIT"; - default: - return "Unhandled XGL_DEVICE_CREATE_FLAGS"; - } -} - - -static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) -{ - switch ((XGL_COMPARE_FUNC)input_value) - { - case XGL_COMPARE_ALWAYS: - return "XGL_COMPARE_ALWAYS"; - case XGL_COMPARE_EQUAL: - return "XGL_COMPARE_EQUAL"; - case XGL_COMPARE_GREATER: - return "XGL_COMPARE_GREATER"; - case XGL_COMPARE_GREATER_EQUAL: - return "XGL_COMPARE_GREATER_EQUAL"; - case XGL_COMPARE_LESS: - return "XGL_COMPARE_LESS"; - case XGL_COMPARE_LESS_EQUAL: - return "XGL_COMPARE_LESS_EQUAL"; - case XGL_COMPARE_NEVER: - return "XGL_COMPARE_NEVER"; - case XGL_COMPARE_NOT_EQUAL: - return "XGL_COMPARE_NOT_EQUAL"; - default: - return "Unhandled XGL_COMPARE_FUNC"; - } -} - - -static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) -{ - switch ((XGL_SHADER_STAGE_FLAGS)input_value) - { - case XGL_SHADER_STAGE_FLAGS_ALL: - return "XGL_SHADER_STAGE_FLAGS_ALL"; - case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT: - return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT"; - case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT: - return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT"; - case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT: - return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT"; - case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT: - return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT"; - case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT: - return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT"; - case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT: - return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT"; - default: - return "Unhandled XGL_SHADER_STAGE_FLAGS"; - } -} - - -static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value) -{ - switch ((XGL_FILL_MODE)input_value) - { - case XGL_FILL_POINTS: - return "XGL_FILL_POINTS"; - case XGL_FILL_SOLID: - return "XGL_FILL_SOLID"; - case XGL_FILL_WIREFRAME: - return "XGL_FILL_WIREFRAME"; - default: - return "Unhandled XGL_FILL_MODE"; - } -} - - -static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) -{ - switch ((XGL_COORDINATE_ORIGIN)input_value) - { - case XGL_COORDINATE_ORIGIN_LOWER_LEFT: - return "XGL_COORDINATE_ORIGIN_LOWER_LEFT"; - case XGL_COORDINATE_ORIGIN_UPPER_LEFT: - return "XGL_COORDINATE_ORIGIN_UPPER_LEFT"; - default: - return "Unhandled XGL_COORDINATE_ORIGIN"; - } -} - - -static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) -{ - switch ((XGL_WAIT_EVENT)input_value) - { - case XGL_WAIT_EVENT_BEFORE_RASTERIZATION: - return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION"; - case XGL_WAIT_EVENT_TOP_OF_PIPE: - return "XGL_WAIT_EVENT_TOP_OF_PIPE"; - default: - return "Unhandled XGL_WAIT_EVENT"; - } -} - - -static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) -{ - switch ((XGL_DESCRIPTOR_TYPE)input_value) - { - case XGL_DESCRIPTOR_TYPE_IMAGE: - return "XGL_DESCRIPTOR_TYPE_IMAGE"; - case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER: - return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER"; - case XGL_DESCRIPTOR_TYPE_RAW_BUFFER: - return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER"; - case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC: - return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC"; - case XGL_DESCRIPTOR_TYPE_SAMPLER: - return "XGL_DESCRIPTOR_TYPE_SAMPLER"; - case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE: - return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE"; - case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER: - return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER"; - case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC: - return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC"; - case XGL_DESCRIPTOR_TYPE_TEXTURE: - return "XGL_DESCRIPTOR_TYPE_TEXTURE"; - case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER: - return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER"; - case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER"; - case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"; - default: - return "Unhandled XGL_DESCRIPTOR_TYPE"; - } -} - - -static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) -{ - switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) - { - case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: - return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT"; - default: - return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS"; - } -} - - -static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) -{ - switch ((XGL_MEMORY_PRIORITY)input_value) - { - case XGL_MEMORY_PRIORITY_HIGH: - return "XGL_MEMORY_PRIORITY_HIGH"; - case XGL_MEMORY_PRIORITY_LOW: - return "XGL_MEMORY_PRIORITY_LOW"; - case XGL_MEMORY_PRIORITY_NORMAL: - return "XGL_MEMORY_PRIORITY_NORMAL"; - case XGL_MEMORY_PRIORITY_UNUSED: - return "XGL_MEMORY_PRIORITY_UNUSED"; - case XGL_MEMORY_PRIORITY_VERY_HIGH: - return "XGL_MEMORY_PRIORITY_VERY_HIGH"; - case XGL_MEMORY_PRIORITY_VERY_LOW: - return "XGL_MEMORY_PRIORITY_VERY_LOW"; - default: - return "Unhandled XGL_MEMORY_PRIORITY"; - } -} - - -static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) -{ - switch ((XGL_TIMESTAMP_TYPE)input_value) - { - case XGL_TIMESTAMP_BOTTOM: - return "XGL_TIMESTAMP_BOTTOM"; - case XGL_TIMESTAMP_TOP: - return "XGL_TIMESTAMP_TOP"; - default: - return "Unhandled XGL_TIMESTAMP_TYPE"; - } -} - - -static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) -{ - switch ((XGL_PHYSICAL_GPU_TYPE)input_value) - { - case XGL_GPU_TYPE_DISCRETE: - return "XGL_GPU_TYPE_DISCRETE"; - case XGL_GPU_TYPE_INTEGRATED: - return "XGL_GPU_TYPE_INTEGRATED"; - case XGL_GPU_TYPE_OTHER: - return "XGL_GPU_TYPE_OTHER"; - case XGL_GPU_TYPE_VIRTUAL: - return "XGL_GPU_TYPE_VIRTUAL"; - default: - return "Unhandled XGL_PHYSICAL_GPU_TYPE"; - } -} - - -static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value) -{ - switch ((XGL_PRIMITIVE_TOPOLOGY)input_value) - { - case XGL_TOPOLOGY_LINE_LIST: - return "XGL_TOPOLOGY_LINE_LIST"; - case XGL_TOPOLOGY_LINE_LIST_ADJ: - return "XGL_TOPOLOGY_LINE_LIST_ADJ"; - case XGL_TOPOLOGY_LINE_STRIP: - return "XGL_TOPOLOGY_LINE_STRIP"; - case XGL_TOPOLOGY_LINE_STRIP_ADJ: - return "XGL_TOPOLOGY_LINE_STRIP_ADJ"; - case XGL_TOPOLOGY_PATCH: - return "XGL_TOPOLOGY_PATCH"; - case XGL_TOPOLOGY_POINT_LIST: - return "XGL_TOPOLOGY_POINT_LIST"; - case XGL_TOPOLOGY_QUAD_LIST: - return "XGL_TOPOLOGY_QUAD_LIST"; - case XGL_TOPOLOGY_QUAD_STRIP: - return "XGL_TOPOLOGY_QUAD_STRIP"; - case XGL_TOPOLOGY_RECT_LIST: - return "XGL_TOPOLOGY_RECT_LIST"; - case XGL_TOPOLOGY_TRIANGLE_LIST: - return "XGL_TOPOLOGY_TRIANGLE_LIST"; - case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ: - return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ"; - case XGL_TOPOLOGY_TRIANGLE_STRIP: - return "XGL_TOPOLOGY_TRIANGLE_STRIP"; - case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ: - return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ"; - default: - return "Unhandled XGL_PRIMITIVE_TOPOLOGY"; - } -} - - -static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value) -{ - switch ((XGL_IMAGE_VIEW_TYPE)input_value) - { - case XGL_IMAGE_VIEW_1D: - return "XGL_IMAGE_VIEW_1D"; - case XGL_IMAGE_VIEW_2D: - return "XGL_IMAGE_VIEW_2D"; - case XGL_IMAGE_VIEW_3D: - return "XGL_IMAGE_VIEW_3D"; - case XGL_IMAGE_VIEW_CUBE: - return "XGL_IMAGE_VIEW_CUBE"; - default: - return "Unhandled XGL_IMAGE_VIEW_TYPE"; - } -} - - -static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value) -{ - switch ((XGL_DESCRIPTOR_SET_USAGE)input_value) - { - case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT: - return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT"; - case XGL_DESCRIPTOR_SET_USAGE_STATIC: - return "XGL_DESCRIPTOR_SET_USAGE_STATIC"; - default: - return "Unhandled XGL_DESCRIPTOR_SET_USAGE"; - } -} - - -static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) -{ - switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) - { - case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: - return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT"; - default: - return "Unhandled XGL_SUBRESOURCE_INFO_TYPE"; - } -} - - -static inline const char* string_XGL_RESULT(XGL_RESULT input_value) -{ - switch ((XGL_RESULT)input_value) - { - case XGL_ERROR_BAD_PIPELINE_DATA: - return "XGL_ERROR_BAD_PIPELINE_DATA"; - case XGL_ERROR_BAD_SHADER_CODE: - return "XGL_ERROR_BAD_SHADER_CODE"; - case XGL_ERROR_BUILDING_COMMAND_BUFFER: - return "XGL_ERROR_BUILDING_COMMAND_BUFFER"; - case XGL_ERROR_DEVICE_ALREADY_CREATED: - return "XGL_ERROR_DEVICE_ALREADY_CREATED"; - case XGL_ERROR_DEVICE_LOST: - return "XGL_ERROR_DEVICE_LOST"; - case XGL_ERROR_INCOMPATIBLE_DEVICE: - return "XGL_ERROR_INCOMPATIBLE_DEVICE"; - case XGL_ERROR_INCOMPATIBLE_DRIVER: - return "XGL_ERROR_INCOMPATIBLE_DRIVER"; - case XGL_ERROR_INCOMPATIBLE_QUEUE: - return "XGL_ERROR_INCOMPATIBLE_QUEUE"; - case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER: - return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER"; - case XGL_ERROR_INITIALIZATION_FAILED: - return "XGL_ERROR_INITIALIZATION_FAILED"; - case XGL_ERROR_INVALID_ALIGNMENT: - return "XGL_ERROR_INVALID_ALIGNMENT"; - case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA: - return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA"; - case XGL_ERROR_INVALID_EXTENSION: - return "XGL_ERROR_INVALID_EXTENSION"; - case XGL_ERROR_INVALID_FLAGS: - return "XGL_ERROR_INVALID_FLAGS"; - case XGL_ERROR_INVALID_FORMAT: - return "XGL_ERROR_INVALID_FORMAT"; - case XGL_ERROR_INVALID_HANDLE: - return "XGL_ERROR_INVALID_HANDLE"; - case XGL_ERROR_INVALID_IMAGE: - return "XGL_ERROR_INVALID_IMAGE"; - case XGL_ERROR_INVALID_MEMORY_SIZE: - return "XGL_ERROR_INVALID_MEMORY_SIZE"; - case XGL_ERROR_INVALID_OBJECT_TYPE: - return "XGL_ERROR_INVALID_OBJECT_TYPE"; - case XGL_ERROR_INVALID_ORDINAL: - return "XGL_ERROR_INVALID_ORDINAL"; - case XGL_ERROR_INVALID_POINTER: - return "XGL_ERROR_INVALID_POINTER"; - case XGL_ERROR_INVALID_QUEUE_TYPE: - return "XGL_ERROR_INVALID_QUEUE_TYPE"; - case XGL_ERROR_INVALID_VALUE: - return "XGL_ERROR_INVALID_VALUE"; - case XGL_ERROR_MEMORY_MAP_FAILED: - return "XGL_ERROR_MEMORY_MAP_FAILED"; - case XGL_ERROR_MEMORY_NOT_BOUND: - return "XGL_ERROR_MEMORY_NOT_BOUND"; - case XGL_ERROR_MEMORY_UNMAP_FAILED: - return "XGL_ERROR_MEMORY_UNMAP_FAILED"; - case XGL_ERROR_NOT_MAPPABLE: - return "XGL_ERROR_NOT_MAPPABLE"; - case XGL_ERROR_NOT_SHAREABLE: - return "XGL_ERROR_NOT_SHAREABLE"; - case XGL_ERROR_OUT_OF_GPU_MEMORY: - return "XGL_ERROR_OUT_OF_GPU_MEMORY"; - case XGL_ERROR_OUT_OF_MEMORY: - return "XGL_ERROR_OUT_OF_MEMORY"; - case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES: - return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES"; - case XGL_ERROR_UNAVAILABLE: - return "XGL_ERROR_UNAVAILABLE"; - case XGL_ERROR_UNKNOWN: - return "XGL_ERROR_UNKNOWN"; - case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION: - return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION"; - case XGL_EVENT_RESET: - return "XGL_EVENT_RESET"; - case XGL_EVENT_SET: - return "XGL_EVENT_SET"; - case XGL_NOT_READY: - return "XGL_NOT_READY"; - case XGL_SUCCESS: - return "XGL_SUCCESS"; - case XGL_TIMEOUT: - return "XGL_TIMEOUT"; - case XGL_UNSUPPORTED: - return "XGL_UNSUPPORTED"; - default: - return "Unhandled XGL_RESULT"; - } -} - - -static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) -{ - switch ((XGL_BORDER_COLOR_TYPE)input_value) - { - case XGL_BORDER_COLOR_OPAQUE_BLACK: - return "XGL_BORDER_COLOR_OPAQUE_BLACK"; - case XGL_BORDER_COLOR_OPAQUE_WHITE: - return "XGL_BORDER_COLOR_OPAQUE_WHITE"; - case XGL_BORDER_COLOR_TRANSPARENT_BLACK: - return "XGL_BORDER_COLOR_TRANSPARENT_BLACK"; - default: - return "Unhandled XGL_BORDER_COLOR_TYPE"; - } -} - - -static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) -{ - switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value) - { - case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES: - return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES"; - case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE: - return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE"; - case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES: - return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES"; - case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES: - return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES"; - default: - return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE"; - } -} - - -static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) -{ - switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) - { - case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT: - return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT"; - case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT: - return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT"; - default: - return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS"; - } -} - - -static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) -{ - switch ((XGL_INDEX_TYPE)input_value) - { - case XGL_INDEX_16: - return "XGL_INDEX_16"; - case XGL_INDEX_32: - return "XGL_INDEX_32"; - case XGL_INDEX_8: - return "XGL_INDEX_8"; - default: - return "Unhandled XGL_INDEX_TYPE"; - } -} - - -static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value) -{ - switch ((XGL_CULL_MODE)input_value) - { - case XGL_CULL_BACK: - return "XGL_CULL_BACK"; - case XGL_CULL_FRONT: - return "XGL_CULL_FRONT"; - case XGL_CULL_FRONT_AND_BACK: - return "XGL_CULL_FRONT_AND_BACK"; - case XGL_CULL_NONE: - return "XGL_CULL_NONE"; - default: - return "Unhandled XGL_CULL_MODE"; - } -} - - -static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value) -{ - switch ((XGL_SET_EVENT)input_value) - { - case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE: - return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE"; - case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE: - return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE"; - case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE: - return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE"; - case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE: - return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE"; - case XGL_SET_EVENT_TOP_OF_PIPE: - return "XGL_SET_EVENT_TOP_OF_PIPE"; - case XGL_SET_EVENT_TRANSFER_COMPLETE: - return "XGL_SET_EVENT_TRANSFER_COMPLETE"; - case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE: - return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE"; - default: - return "Unhandled XGL_SET_EVENT"; - } -} - - -static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) -{ - switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value) - { - case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT: - return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT"; - case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT: - return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT"; - case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT: - return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT"; - case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT: - return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT"; - case XGL_MEMORY_PROPERTY_GPU_ONLY: - return "XGL_MEMORY_PROPERTY_GPU_ONLY"; - case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL: - return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL"; - case XGL_MEMORY_PROPERTY_SHAREABLE_BIT: - return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT"; - default: - return "Unhandled XGL_MEMORY_PROPERTY_FLAGS"; - } -} - - -static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) -{ - switch ((XGL_ATTACHMENT_LOAD_OP)input_value) - { - case XGL_ATTACHMENT_LOAD_OP_CLEAR: - return "XGL_ATTACHMENT_LOAD_OP_CLEAR"; - case XGL_ATTACHMENT_LOAD_OP_DONT_CARE: - return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE"; - case XGL_ATTACHMENT_LOAD_OP_LOAD: - return "XGL_ATTACHMENT_LOAD_OP_LOAD"; - default: - return "Unhandled XGL_ATTACHMENT_LOAD_OP"; - } -} - - -static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) -{ - switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value) - { - case XGL_PROVOKING_VERTEX_FIRST: - return "XGL_PROVOKING_VERTEX_FIRST"; - case XGL_PROVOKING_VERTEX_LAST: - return "XGL_PROVOKING_VERTEX_LAST"; - default: - return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION"; - } -} - - -static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) -{ - switch ((XGL_VALIDATION_LEVEL)input_value) - { - case XGL_VALIDATION_LEVEL_0: - return "XGL_VALIDATION_LEVEL_0"; - case XGL_VALIDATION_LEVEL_1: - return "XGL_VALIDATION_LEVEL_1"; - case XGL_VALIDATION_LEVEL_2: - return "XGL_VALIDATION_LEVEL_2"; - case XGL_VALIDATION_LEVEL_3: - return "XGL_VALIDATION_LEVEL_3"; - case XGL_VALIDATION_LEVEL_4: - return "XGL_VALIDATION_LEVEL_4"; - default: - return "Unhandled XGL_VALIDATION_LEVEL"; - } -} - - -static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) -{ - switch ((XGL_FACE_ORIENTATION)input_value) - { - case XGL_FRONT_FACE_CCW: - return "XGL_FRONT_FACE_CCW"; - case XGL_FRONT_FACE_CW: - return "XGL_FRONT_FACE_CW"; - default: - return "Unhandled XGL_FACE_ORIENTATION"; - } -} - - -static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value) -{ - switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value) - { - case XGL_VERTEX_INPUT_STEP_RATE_DRAW: - return "XGL_VERTEX_INPUT_STEP_RATE_DRAW"; - case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE: - return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE"; - case XGL_VERTEX_INPUT_STEP_RATE_VERTEX: - return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX"; - default: - return "Unhandled XGL_VERTEX_INPUT_STEP_RATE"; - } -} - - -static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) -{ - switch ((XGL_QUEUE_FLAGS)input_value) - { - case XGL_QUEUE_COMPUTE_BIT: - return "XGL_QUEUE_COMPUTE_BIT"; - case XGL_QUEUE_DMA_BIT: - return "XGL_QUEUE_DMA_BIT"; - case XGL_QUEUE_EXTENDED_BIT: - return "XGL_QUEUE_EXTENDED_BIT"; - case XGL_QUEUE_GRAPHICS_BIT: - return "XGL_QUEUE_GRAPHICS_BIT"; - default: - return "Unhandled XGL_QUEUE_FLAGS"; - } -} - - -static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) -{ - switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) - { - case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC: - return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC"; - case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: - return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT"; - default: - return "Unhandled XGL_DESCRIPTOR_REGION_USAGE"; - } -} - - -static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) -{ - switch ((XGL_TEX_MIPMAP_MODE)input_value) - { - case XGL_TEX_MIPMAP_BASE: - return "XGL_TEX_MIPMAP_BASE"; - case XGL_TEX_MIPMAP_LINEAR: - return "XGL_TEX_MIPMAP_LINEAR"; - case XGL_TEX_MIPMAP_NEAREST: - return "XGL_TEX_MIPMAP_NEAREST"; - default: - return "Unhandled XGL_TEX_MIPMAP_MODE"; - } -} - - -static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) -{ - switch ((XGL_QUERY_CONTROL_FLAGS)input_value) - { - case XGL_QUERY_IMPRECISE_DATA_BIT: - return "XGL_QUERY_IMPRECISE_DATA_BIT"; - default: - return "Unhandled XGL_QUERY_CONTROL_FLAGS"; - } -} - - -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"; @@ -1438,101 +442,977 @@ 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_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) +{ + switch ((XGL_BUFFER_CREATE_FLAGS)input_value) + { + case XGL_BUFFER_CREATE_SHAREABLE_BIT: + return "XGL_BUFFER_CREATE_SHAREABLE_BIT"; + case XGL_BUFFER_CREATE_SPARSE_BIT: + return "XGL_BUFFER_CREATE_SPARSE_BIT"; + default: + return "Unhandled XGL_BUFFER_CREATE_FLAGS"; + } +} + + +static inline const char* string_XGL_MEMORY_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_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_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) +{ + switch ((XGL_COORDINATE_ORIGIN)input_value) + { + case XGL_COORDINATE_ORIGIN_LOWER_LEFT: + return "XGL_COORDINATE_ORIGIN_LOWER_LEFT"; + case XGL_COORDINATE_ORIGIN_UPPER_LEFT: + return "XGL_COORDINATE_ORIGIN_UPPER_LEFT"; + default: + return "Unhandled XGL_COORDINATE_ORIGIN"; + } +} + + +static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value) +{ + switch ((XGL_CULL_MODE)input_value) + { + case XGL_CULL_BACK: + return "XGL_CULL_BACK"; + case XGL_CULL_FRONT: + return "XGL_CULL_FRONT"; + case XGL_CULL_FRONT_AND_BACK: + return "XGL_CULL_FRONT_AND_BACK"; + case XGL_CULL_NONE: + return "XGL_CULL_NONE"; + default: + return "Unhandled XGL_CULL_MODE"; + } +} + + +static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value) +{ + switch ((XGL_IMAGE_USAGE_FLAGS)input_value) + { + case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: + return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"; + case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT: + return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT"; + case XGL_IMAGE_USAGE_GENERAL: + return "XGL_IMAGE_USAGE_GENERAL"; + case XGL_IMAGE_USAGE_IMAGE_BIT: + return "XGL_IMAGE_USAGE_IMAGE_BIT"; + case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT: + return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT"; + case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT: + return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT"; + case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT: + return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT"; + case XGL_IMAGE_USAGE_TEXTURE_BIT: + return "XGL_IMAGE_USAGE_TEXTURE_BIT"; + case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT: + return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT"; + case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT: + return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT"; + default: + return "Unhandled XGL_IMAGE_USAGE_FLAGS"; + } +} + + +static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) +{ + switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value) + { + case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT: + return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT"; + case XGL_MEMORY_OUTPUT_COPY_BIT: + return "XGL_MEMORY_OUTPUT_COPY_BIT"; + case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT: + return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT"; + case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT: + return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT"; + case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT: + return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT"; + default: + return "Unhandled XGL_MEMORY_OUTPUT_FLAGS"; + } +} + + +static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value) +{ + switch ((XGL_SET_EVENT)input_value) + { + case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE: + return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE"; + case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE: + return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE"; + case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE: + return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE"; + case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE: + return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE"; + case XGL_SET_EVENT_TOP_OF_PIPE: + return "XGL_SET_EVENT_TOP_OF_PIPE"; + case XGL_SET_EVENT_TRANSFER_COMPLETE: + return "XGL_SET_EVENT_TRANSFER_COMPLETE"; + case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE: + return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE"; + default: + return "Unhandled XGL_SET_EVENT"; + } +} + + +static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value) +{ + switch ((XGL_MEMORY_INPUT_FLAGS)input_value) + { + case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT: + return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT"; + case XGL_MEMORY_INPUT_COPY_BIT: + return "XGL_MEMORY_INPUT_COPY_BIT"; + case XGL_MEMORY_INPUT_CPU_READ_BIT: + return "XGL_MEMORY_INPUT_CPU_READ_BIT"; + case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT: + return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT"; + case XGL_MEMORY_INPUT_INDEX_FETCH_BIT: + return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT"; + case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT: + return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT"; + case XGL_MEMORY_INPUT_SHADER_READ_BIT: + return "XGL_MEMORY_INPUT_SHADER_READ_BIT"; + case XGL_MEMORY_INPUT_UNIFORM_READ_BIT: + return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT"; + case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT: + return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT"; + default: + return "Unhandled XGL_MEMORY_INPUT_FLAGS"; + } +} + + +static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) +{ + switch ((XGL_TEX_MIPMAP_MODE)input_value) + { + case XGL_TEX_MIPMAP_BASE: + return "XGL_TEX_MIPMAP_BASE"; + case XGL_TEX_MIPMAP_LINEAR: + return "XGL_TEX_MIPMAP_LINEAR"; + case XGL_TEX_MIPMAP_NEAREST: + return "XGL_TEX_MIPMAP_NEAREST"; + default: + return "Unhandled XGL_TEX_MIPMAP_MODE"; + } +} + + +static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) +{ + switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value) + { + case XGL_DESCRIPTOR_UDPATE_MODE_COPY: + return "XGL_DESCRIPTOR_UDPATE_MODE_COPY"; + case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST: + return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST"; + default: + return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE"; + } +} + + +static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value) +{ + switch ((XGL_STRUCTURE_TYPE)input_value) + { + case XGL_STRUCTURE_TYPE_APPLICATION_INFO: + return "XGL_STRUCTURE_TYPE_APPLICATION_INFO"; + case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: + return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"; + case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO: + return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO"; + case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO: + return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO"; + case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO: + return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO"; + case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO: + return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO"; + case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: + return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"; + case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO: + return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO"; + case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO: + return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO"; + case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO: + return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO"; + case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO: + return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO"; + case XGL_STRUCTURE_TYPE_MEMORY_BARRIER: + return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER"; + case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO: + return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO"; + case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO: + return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER: + return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER"; + case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO: + return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO"; + case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO: + return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO"; + case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY: + return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY"; + case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS: + return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS"; + case XGL_STRUCTURE_TYPE_UPDATE_IMAGES: + return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES"; + case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS: + return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS"; + case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: + return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES"; + default: + return "Unhandled XGL_STRUCTURE_TYPE"; + } +} + + +static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) +{ + switch ((XGL_MEMORY_REF_FLAGS)input_value) + { + case XGL_MEMORY_REF_READ_ONLY_BIT: + return "XGL_MEMORY_REF_READ_ONLY_BIT"; + default: + return "Unhandled XGL_MEMORY_REF_FLAGS"; + } +} + + +static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value) +{ + switch ((XGL_DESCRIPTOR_SET_USAGE)input_value) + { + case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT: + return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT"; + case XGL_DESCRIPTOR_SET_USAGE_STATIC: + return "XGL_DESCRIPTOR_SET_USAGE_STATIC"; + default: + return "Unhandled XGL_DESCRIPTOR_SET_USAGE"; + } +} + + +static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) +{ + switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) + { + case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: + return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT"; + default: + return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS"; + } +} + + +static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) +{ + switch ((XGL_WAIT_EVENT)input_value) + { + case XGL_WAIT_EVENT_BEFORE_RASTERIZATION: + return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION"; + case XGL_WAIT_EVENT_TOP_OF_PIPE: + return "XGL_WAIT_EVENT_TOP_OF_PIPE"; + default: + return "Unhandled XGL_WAIT_EVENT"; + } +} + + +static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) +{ + switch ((XGL_QUEUE_FLAGS)input_value) + { + case XGL_QUEUE_COMPUTE_BIT: + return "XGL_QUEUE_COMPUTE_BIT"; + case XGL_QUEUE_DMA_BIT: + return "XGL_QUEUE_DMA_BIT"; + case XGL_QUEUE_EXTENDED_BIT: + return "XGL_QUEUE_EXTENDED_BIT"; + case XGL_QUEUE_GRAPHICS_BIT: + return "XGL_QUEUE_GRAPHICS_BIT"; + default: + return "Unhandled XGL_QUEUE_FLAGS"; + } +} + + +static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) +{ + switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) + { + case XGL_SYSTEM_ALLOC_API_OBJECT: + return "XGL_SYSTEM_ALLOC_API_OBJECT"; + case XGL_SYSTEM_ALLOC_DEBUG: + return "XGL_SYSTEM_ALLOC_DEBUG"; + case XGL_SYSTEM_ALLOC_INTERNAL: + return "XGL_SYSTEM_ALLOC_INTERNAL"; + case XGL_SYSTEM_ALLOC_INTERNAL_SHADER: + return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER"; + case XGL_SYSTEM_ALLOC_INTERNAL_TEMP: + return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP"; + default: + return "Unhandled XGL_SYSTEM_ALLOC_TYPE"; + } +} + + +static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) +{ + switch ((XGL_VALIDATION_LEVEL)input_value) + { + case XGL_VALIDATION_LEVEL_0: + return "XGL_VALIDATION_LEVEL_0"; + case XGL_VALIDATION_LEVEL_1: + return "XGL_VALIDATION_LEVEL_1"; + case XGL_VALIDATION_LEVEL_2: + return "XGL_VALIDATION_LEVEL_2"; + case XGL_VALIDATION_LEVEL_3: + return "XGL_VALIDATION_LEVEL_3"; + case XGL_VALIDATION_LEVEL_4: + return "XGL_VALIDATION_LEVEL_4"; + default: + return "Unhandled XGL_VALIDATION_LEVEL"; + } +} + + +static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) +{ + switch ((XGL_PHYSICAL_GPU_TYPE)input_value) + { + case XGL_GPU_TYPE_DISCRETE: + return "XGL_GPU_TYPE_DISCRETE"; + case XGL_GPU_TYPE_INTEGRATED: + return "XGL_GPU_TYPE_INTEGRATED"; + case XGL_GPU_TYPE_OTHER: + return "XGL_GPU_TYPE_OTHER"; + case XGL_GPU_TYPE_VIRTUAL: + return "XGL_GPU_TYPE_VIRTUAL"; + default: + return "Unhandled XGL_PHYSICAL_GPU_TYPE"; + } +} + + +static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) +{ + switch ((XGL_IMAGE_LAYOUT)input_value) + { + case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL: + return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL"; + case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: + return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"; + case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: + return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"; + case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: + return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"; + case XGL_IMAGE_LAYOUT_GENERAL: + return "XGL_IMAGE_LAYOUT_GENERAL"; + case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: + return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"; + case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL: + return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL"; + case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL: + return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL"; + default: + return "Unhandled XGL_IMAGE_LAYOUT"; + } +} + + +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_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) +{ + switch ((XGL_QUEUE_TYPE)input_value) + { + case XGL_QUEUE_TYPE_COMPUTE: + return "XGL_QUEUE_TYPE_COMPUTE"; + case XGL_QUEUE_TYPE_DMA: + return "XGL_QUEUE_TYPE_DMA"; + case XGL_QUEUE_TYPE_GRAPHICS: + return "XGL_QUEUE_TYPE_GRAPHICS"; + default: + return "Unhandled XGL_QUEUE_TYPE"; + } +} + + +static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) +{ + switch ((XGL_SHADER_STAGE_FLAGS)input_value) + { + case XGL_SHADER_STAGE_FLAGS_ALL: + return "XGL_SHADER_STAGE_FLAGS_ALL"; + case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT: + return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT"; + case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT: + return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT"; + case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT: + return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT"; + case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT: + return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT"; + case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT: + return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT"; + case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT: + return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT"; + default: + return "Unhandled XGL_SHADER_STAGE_FLAGS"; + } +} + + +static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value) +{ + switch ((XGL_PRIMITIVE_TOPOLOGY)input_value) + { + case XGL_TOPOLOGY_LINE_LIST: + return "XGL_TOPOLOGY_LINE_LIST"; + case XGL_TOPOLOGY_LINE_LIST_ADJ: + return "XGL_TOPOLOGY_LINE_LIST_ADJ"; + case XGL_TOPOLOGY_LINE_STRIP: + return "XGL_TOPOLOGY_LINE_STRIP"; + case XGL_TOPOLOGY_LINE_STRIP_ADJ: + return "XGL_TOPOLOGY_LINE_STRIP_ADJ"; + case XGL_TOPOLOGY_PATCH: + return "XGL_TOPOLOGY_PATCH"; + case XGL_TOPOLOGY_POINT_LIST: + return "XGL_TOPOLOGY_POINT_LIST"; + case XGL_TOPOLOGY_QUAD_LIST: + return "XGL_TOPOLOGY_QUAD_LIST"; + case XGL_TOPOLOGY_QUAD_STRIP: + return "XGL_TOPOLOGY_QUAD_STRIP"; + case XGL_TOPOLOGY_RECT_LIST: + return "XGL_TOPOLOGY_RECT_LIST"; + case XGL_TOPOLOGY_TRIANGLE_LIST: + return "XGL_TOPOLOGY_TRIANGLE_LIST"; + case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ: + return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ"; + case XGL_TOPOLOGY_TRIANGLE_STRIP: + return "XGL_TOPOLOGY_TRIANGLE_STRIP"; + case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ: + return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ"; + default: + return "Unhandled XGL_PRIMITIVE_TOPOLOGY"; + } +} + + +static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) +{ + switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) + { + case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT: + return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT"; + case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT: + return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT"; + default: + return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS"; + } +} + + +static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) +{ + switch ((XGL_IMAGE_TILING)input_value) + { + case XGL_LINEAR_TILING: + return "XGL_LINEAR_TILING"; + case XGL_OPTIMAL_TILING: + return "XGL_OPTIMAL_TILING"; + default: + return "Unhandled XGL_IMAGE_TILING"; + } +} + + +static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value) +{ + switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value) + { + case XGL_VERTEX_INPUT_STEP_RATE_DRAW: + return "XGL_VERTEX_INPUT_STEP_RATE_DRAW"; + case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE: + return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE"; + case XGL_VERTEX_INPUT_STEP_RATE_VERTEX: + return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX"; + default: + return "Unhandled XGL_VERTEX_INPUT_STEP_RATE"; + } +} + + +static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value) +{ + switch ((XGL_DEVICE_CREATE_FLAGS)input_value) + { + case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT: + return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT"; + case XGL_DEVICE_CREATE_VALIDATION_BIT: + return "XGL_DEVICE_CREATE_VALIDATION_BIT"; + default: + return "Unhandled XGL_DEVICE_CREATE_FLAGS"; } } -static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) +static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) { - switch ((XGL_DEPTH_MODE)input_value) + switch ((XGL_OBJECT_INFO_TYPE)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_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_DEPTH_MODE"; + 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) + switch ((XGL_BUFFER_VIEW_TYPE)input_value) + { + case XGL_BUFFER_VIEW_RAW: + return "XGL_BUFFER_VIEW_RAW"; + case XGL_BUFFER_VIEW_STRUCTURED: + return "XGL_BUFFER_VIEW_STRUCTURED"; + case XGL_BUFFER_VIEW_TYPED: + return "XGL_BUFFER_VIEW_TYPED"; + default: + return "Unhandled XGL_BUFFER_VIEW_TYPE"; + } +} + + +static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) +{ + switch ((XGL_DESCRIPTOR_TYPE)input_value) + { + case XGL_DESCRIPTOR_TYPE_IMAGE: + return "XGL_DESCRIPTOR_TYPE_IMAGE"; + case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_RAW_BUFFER: + return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER"; + case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC"; + case XGL_DESCRIPTOR_TYPE_SAMPLER: + return "XGL_DESCRIPTOR_TYPE_SAMPLER"; + case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE: + return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE"; + case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC"; + case XGL_DESCRIPTOR_TYPE_TEXTURE: + return "XGL_DESCRIPTOR_TYPE_TEXTURE"; + case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER: + return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER"; + case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER"; + case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"; + default: + return "Unhandled XGL_DESCRIPTOR_TYPE"; + } +} + + +static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) +{ + switch ((XGL_IMAGE_TYPE)input_value) + { + case XGL_IMAGE_1D: + return "XGL_IMAGE_1D"; + case XGL_IMAGE_2D: + return "XGL_IMAGE_2D"; + case XGL_IMAGE_3D: + return "XGL_IMAGE_3D"; + default: + return "Unhandled XGL_IMAGE_TYPE"; + } +} + + +static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) +{ + switch ((XGL_BLEND_FUNC)input_value) + { + case XGL_BLEND_FUNC_ADD: + return "XGL_BLEND_FUNC_ADD"; + case XGL_BLEND_FUNC_MAX: + return "XGL_BLEND_FUNC_MAX"; + case XGL_BLEND_FUNC_MIN: + return "XGL_BLEND_FUNC_MIN"; + case XGL_BLEND_FUNC_REVERSE_SUBTRACT: + return "XGL_BLEND_FUNC_REVERSE_SUBTRACT"; + case XGL_BLEND_FUNC_SUBTRACT: + return "XGL_BLEND_FUNC_SUBTRACT"; + default: + return "Unhandled XGL_BLEND_FUNC"; + } +} + + +static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) +{ + switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) + { + case XGL_GPU_COMPAT_ASIC_FEATURES_BIT: + return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT"; + case XGL_GPU_COMPAT_IQ_MATCH_BIT: + return "XGL_GPU_COMPAT_IQ_MATCH_BIT"; + case XGL_GPU_COMPAT_PEER_TRANSFER_BIT: + return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT"; + case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT: + return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT"; + case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT: + return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT"; + case XGL_GPU_COMPAT_SHARED_MEMORY_BIT: + return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT"; + case XGL_GPU_COMPAT_SHARED_SYNC_BIT: + return "XGL_GPU_COMPAT_SHARED_SYNC_BIT"; + default: + return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS"; + } +} + + +static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) +{ + switch ((XGL_MEMORY_PRIORITY)input_value) + { + case XGL_MEMORY_PRIORITY_HIGH: + return "XGL_MEMORY_PRIORITY_HIGH"; + case XGL_MEMORY_PRIORITY_LOW: + return "XGL_MEMORY_PRIORITY_LOW"; + case XGL_MEMORY_PRIORITY_NORMAL: + return "XGL_MEMORY_PRIORITY_NORMAL"; + case XGL_MEMORY_PRIORITY_UNUSED: + return "XGL_MEMORY_PRIORITY_UNUSED"; + case XGL_MEMORY_PRIORITY_VERY_HIGH: + return "XGL_MEMORY_PRIORITY_VERY_HIGH"; + case XGL_MEMORY_PRIORITY_VERY_LOW: + return "XGL_MEMORY_PRIORITY_VERY_LOW"; + default: + return "Unhandled XGL_MEMORY_PRIORITY"; + } +} + + +static inline const char* string_XGL_RESULT(XGL_RESULT input_value) +{ + switch ((XGL_RESULT)input_value) + { + case XGL_ERROR_BAD_PIPELINE_DATA: + return "XGL_ERROR_BAD_PIPELINE_DATA"; + case XGL_ERROR_BAD_SHADER_CODE: + return "XGL_ERROR_BAD_SHADER_CODE"; + case XGL_ERROR_BUILDING_COMMAND_BUFFER: + return "XGL_ERROR_BUILDING_COMMAND_BUFFER"; + case XGL_ERROR_DEVICE_ALREADY_CREATED: + return "XGL_ERROR_DEVICE_ALREADY_CREATED"; + case XGL_ERROR_DEVICE_LOST: + return "XGL_ERROR_DEVICE_LOST"; + case XGL_ERROR_INCOMPATIBLE_DEVICE: + return "XGL_ERROR_INCOMPATIBLE_DEVICE"; + case XGL_ERROR_INCOMPATIBLE_DRIVER: + return "XGL_ERROR_INCOMPATIBLE_DRIVER"; + case XGL_ERROR_INCOMPATIBLE_QUEUE: + return "XGL_ERROR_INCOMPATIBLE_QUEUE"; + case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER: + return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER"; + case XGL_ERROR_INITIALIZATION_FAILED: + return "XGL_ERROR_INITIALIZATION_FAILED"; + case XGL_ERROR_INVALID_ALIGNMENT: + return "XGL_ERROR_INVALID_ALIGNMENT"; + case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA: + return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA"; + case XGL_ERROR_INVALID_EXTENSION: + return "XGL_ERROR_INVALID_EXTENSION"; + case XGL_ERROR_INVALID_FLAGS: + return "XGL_ERROR_INVALID_FLAGS"; + case XGL_ERROR_INVALID_FORMAT: + return "XGL_ERROR_INVALID_FORMAT"; + case XGL_ERROR_INVALID_HANDLE: + return "XGL_ERROR_INVALID_HANDLE"; + case XGL_ERROR_INVALID_IMAGE: + return "XGL_ERROR_INVALID_IMAGE"; + case XGL_ERROR_INVALID_MEMORY_SIZE: + return "XGL_ERROR_INVALID_MEMORY_SIZE"; + case XGL_ERROR_INVALID_OBJECT_TYPE: + return "XGL_ERROR_INVALID_OBJECT_TYPE"; + case XGL_ERROR_INVALID_ORDINAL: + return "XGL_ERROR_INVALID_ORDINAL"; + case XGL_ERROR_INVALID_POINTER: + return "XGL_ERROR_INVALID_POINTER"; + case XGL_ERROR_INVALID_QUEUE_TYPE: + return "XGL_ERROR_INVALID_QUEUE_TYPE"; + case XGL_ERROR_INVALID_VALUE: + return "XGL_ERROR_INVALID_VALUE"; + case XGL_ERROR_MEMORY_MAP_FAILED: + return "XGL_ERROR_MEMORY_MAP_FAILED"; + case XGL_ERROR_MEMORY_NOT_BOUND: + return "XGL_ERROR_MEMORY_NOT_BOUND"; + case XGL_ERROR_MEMORY_UNMAP_FAILED: + return "XGL_ERROR_MEMORY_UNMAP_FAILED"; + case XGL_ERROR_NOT_MAPPABLE: + return "XGL_ERROR_NOT_MAPPABLE"; + case XGL_ERROR_NOT_SHAREABLE: + return "XGL_ERROR_NOT_SHAREABLE"; + case XGL_ERROR_OUT_OF_GPU_MEMORY: + return "XGL_ERROR_OUT_OF_GPU_MEMORY"; + case XGL_ERROR_OUT_OF_MEMORY: + return "XGL_ERROR_OUT_OF_MEMORY"; + case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES: + return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES"; + case XGL_ERROR_UNAVAILABLE: + return "XGL_ERROR_UNAVAILABLE"; + case XGL_ERROR_UNKNOWN: + return "XGL_ERROR_UNKNOWN"; + case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION: + return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION"; + case XGL_EVENT_RESET: + return "XGL_EVENT_RESET"; + case XGL_EVENT_SET: + return "XGL_EVENT_SET"; + case XGL_NOT_READY: + return "XGL_NOT_READY"; + case XGL_SUCCESS: + return "XGL_SUCCESS"; + case XGL_TIMEOUT: + return "XGL_TIMEOUT"; + case XGL_UNSUPPORTED: + return "XGL_UNSUPPORTED"; + default: + return "Unhandled XGL_RESULT"; + } +} + + +static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value) +{ + switch ((XGL_FILL_MODE)input_value) { - case XGL_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_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_BUFFER_VIEW_TYPE"; + return "Unhandled XGL_FILL_MODE"; } } -static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) +static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) { - switch ((XGL_IMAGE_TYPE)input_value) + switch ((XGL_TEX_FILTER)input_value) { - case XGL_IMAGE_1D: - return "XGL_IMAGE_1D"; - case XGL_IMAGE_2D: - return "XGL_IMAGE_2D"; - case XGL_IMAGE_3D: - return "XGL_IMAGE_3D"; + case XGL_TEX_FILTER_LINEAR: + return "XGL_TEX_FILTER_LINEAR"; + case XGL_TEX_FILTER_NEAREST: + return "XGL_TEX_FILTER_NEAREST"; default: - return "Unhandled XGL_IMAGE_TYPE"; + return "Unhandled XGL_TEX_FILTER"; } } -static inline const char* string_XGL_BLEND(XGL_BLEND input_value) +static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) { - switch ((XGL_BLEND)input_value) + switch ((XGL_QUERY_TYPE)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_QUERY_OCCLUSION: + return "XGL_QUERY_OCCLUSION"; + case XGL_QUERY_PIPELINE_STATISTICS: + return "XGL_QUERY_PIPELINE_STATISTICS"; default: - return "Unhandled XGL_BLEND"; + return "Unhandled XGL_QUERY_TYPE"; } } @@ -1567,144 +1447,184 @@ static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLA } -static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) +static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) { - switch ((XGL_TEX_FILTER)input_value) + switch ((XGL_TIMESTAMP_TYPE)input_value) { - case XGL_TEX_FILTER_LINEAR: - return "XGL_TEX_FILTER_LINEAR"; - case XGL_TEX_FILTER_NEAREST: - return "XGL_TEX_FILTER_NEAREST"; + case XGL_TIMESTAMP_BOTTOM: + return "XGL_TIMESTAMP_BOTTOM"; + case XGL_TIMESTAMP_TOP: + return "XGL_TIMESTAMP_TOP"; default: - return "Unhandled XGL_TEX_FILTER"; + return "Unhandled XGL_TIMESTAMP_TYPE"; } } -static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) +static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) { - switch ((XGL_PIPELINE_SHADER_STAGE)input_value) + switch ((XGL_BORDER_COLOR_TYPE)input_value) { - case XGL_SHADER_STAGE_COMPUTE: - return "XGL_SHADER_STAGE_COMPUTE"; - case XGL_SHADER_STAGE_FRAGMENT: - return "XGL_SHADER_STAGE_FRAGMENT"; - case XGL_SHADER_STAGE_GEOMETRY: - return "XGL_SHADER_STAGE_GEOMETRY"; - case XGL_SHADER_STAGE_TESS_CONTROL: - return "XGL_SHADER_STAGE_TESS_CONTROL"; - case XGL_SHADER_STAGE_TESS_EVALUATION: - return "XGL_SHADER_STAGE_TESS_EVALUATION"; - case XGL_SHADER_STAGE_VERTEX: - return "XGL_SHADER_STAGE_VERTEX"; + case XGL_BORDER_COLOR_OPAQUE_BLACK: + return "XGL_BORDER_COLOR_OPAQUE_BLACK"; + case XGL_BORDER_COLOR_OPAQUE_WHITE: + return "XGL_BORDER_COLOR_OPAQUE_WHITE"; + case XGL_BORDER_COLOR_TRANSPARENT_BLACK: + return "XGL_BORDER_COLOR_TRANSPARENT_BLACK"; default: - return "Unhandled XGL_PIPELINE_SHADER_STAGE"; + return "Unhandled XGL_BORDER_COLOR_TYPE"; } } -static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) +static inline const char* string_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: - return "XGL_BLEND_FUNC_ADD"; - case XGL_BLEND_FUNC_MAX: - return "XGL_BLEND_FUNC_MAX"; - case XGL_BLEND_FUNC_MIN: - return "XGL_BLEND_FUNC_MIN"; - case XGL_BLEND_FUNC_REVERSE_SUBTRACT: - return "XGL_BLEND_FUNC_REVERSE_SUBTRACT"; - case XGL_BLEND_FUNC_SUBTRACT: - return "XGL_BLEND_FUNC_SUBTRACT"; + case XGL_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_BLEND_FUNC"; + return "Unhandled XGL_LOGIC_OP"; } } -static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) +static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) { - switch ((XGL_IMAGE_LAYOUT)input_value) + switch ((XGL_QUERY_CONTROL_FLAGS)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"; + case XGL_QUERY_IMPRECISE_DATA_BIT: + return "XGL_QUERY_IMPRECISE_DATA_BIT"; default: - return "Unhandled XGL_IMAGE_LAYOUT"; + return "Unhandled XGL_QUERY_CONTROL_FLAGS"; } } -static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) +static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) { - switch ((XGL_BUFFER_CREATE_FLAGS)input_value) + switch ((XGL_IMAGE_ASPECT)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_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_BUFFER_CREATE_FLAGS"; + return "Unhandled XGL_IMAGE_ASPECT"; } } -static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) +static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) { - switch ((XGL_MEMORY_TYPE)input_value) + switch ((XGL_ATTACHMENT_LOAD_OP)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_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_MEMORY_TYPE"; + return "Unhandled XGL_ATTACHMENT_LOAD_OP"; } } -static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) +static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) { - switch ((XGL_QUEUE_TYPE)input_value) + switch ((XGL_IMAGE_FORMAT_CLASS)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_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_QUEUE_TYPE"; + return "Unhandled XGL_IMAGE_FORMAT_CLASS"; } } -static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) +static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) { - switch ((XGL_IMAGE_TILING)input_value) + switch ((XGL_TEX_ADDRESS)input_value) { - case XGL_LINEAR_TILING: - return "XGL_LINEAR_TILING"; - case XGL_OPTIMAL_TILING: - return "XGL_OPTIMAL_TILING"; + 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_TILING"; + return "Unhandled XGL_TEX_ADDRESS"; } } @@ -1727,14 +1647,44 @@ static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD } -static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) +static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) { - switch ((XGL_FORMAT_INFO_TYPE)input_value) + switch ((XGL_INDEX_TYPE)input_value) { - case XGL_INFO_TYPE_FORMAT_PROPERTIES: - return "XGL_INFO_TYPE_FORMAT_PROPERTIES"; + 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_FORMAT_INFO_TYPE"; + return "Unhandled XGL_INDEX_TYPE"; + } +} + + +static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) +{ + switch ((XGL_COMPARE_FUNC)input_value) + { + case XGL_COMPARE_ALWAYS: + return "XGL_COMPARE_ALWAYS"; + case XGL_COMPARE_EQUAL: + return "XGL_COMPARE_EQUAL"; + case XGL_COMPARE_GREATER: + return "XGL_COMPARE_GREATER"; + case XGL_COMPARE_GREATER_EQUAL: + return "XGL_COMPARE_GREATER_EQUAL"; + case XGL_COMPARE_LESS: + return "XGL_COMPARE_LESS"; + case XGL_COMPARE_LESS_EQUAL: + return "XGL_COMPARE_LESS_EQUAL"; + case XGL_COMPARE_NEVER: + return "XGL_COMPARE_NEVER"; + case XGL_COMPARE_NOT_EQUAL: + return "XGL_COMPARE_NOT_EQUAL"; + default: + return "Unhandled XGL_COMPARE_FUNC"; } } @@ -1757,46 +1707,82 @@ static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input } -static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) +static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) { - switch ((XGL_TEX_ADDRESS)input_value) + switch ((XGL_STENCIL_OP)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_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_TEX_ADDRESS"; + return "Unhandled XGL_STENCIL_OP"; } } -static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) +static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) { - switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) + switch ((XGL_PHYSICAL_GPU_INFO_TYPE)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_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_GPU_COMPATIBILITY_FLAGS"; + return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE"; + } +} + + +static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) +{ + switch ((XGL_IMAGE_CREATE_FLAGS)input_value) + { + case XGL_IMAGE_CREATE_CLONEABLE_BIT: + return "XGL_IMAGE_CREATE_CLONEABLE_BIT"; + case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT: + return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT"; + case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT: + return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; + case XGL_IMAGE_CREATE_SHAREABLE_BIT: + return "XGL_IMAGE_CREATE_SHAREABLE_BIT"; + case XGL_IMAGE_CREATE_SPARSE_BIT: + return "XGL_IMAGE_CREATE_SPARSE_BIT"; + default: + return "Unhandled XGL_IMAGE_CREATE_FLAGS"; + } +} + + +static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value) +{ + switch ((XGL_ATTACHMENT_STORE_OP)input_value) + { + case XGL_ATTACHMENT_STORE_OP_DONT_CARE: + return "XGL_ATTACHMENT_STORE_OP_DONT_CARE"; + case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA: + return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA"; + case XGL_ATTACHMENT_STORE_OP_STORE: + return "XGL_ATTACHMENT_STORE_OP_STORE"; + default: + return "Unhandled XGL_ATTACHMENT_STORE_OP"; } } @@ -1839,44 +1825,58 @@ static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS i } -static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) +static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value) { - switch ((XGL_LOGIC_OP)input_value) + switch ((XGL_IMAGE_VIEW_TYPE)input_value) { - case XGL_LOGIC_OP_AND: - 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_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_LOGIC_OP"; + return "Unhandled XGL_IMAGE_VIEW_TYPE"; + } +} + + +static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) +{ + switch ((XGL_FORMAT_INFO_TYPE)input_value) + { + case XGL_INFO_TYPE_FORMAT_PROPERTIES: + return "XGL_INFO_TYPE_FORMAT_PROPERTIES"; + default: + return "Unhandled XGL_FORMAT_INFO_TYPE"; + } +} + + +static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) +{ + switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) + { + case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: + return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT"; + default: + return "Unhandled XGL_SUBRESOURCE_INFO_TYPE"; + } +} + + +static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) +{ + switch ((XGL_FACE_ORIENTATION)input_value) + { + case XGL_FRONT_FACE_CCW: + return "XGL_FRONT_FACE_CCW"; + case XGL_FRONT_FACE_CW: + return "XGL_FRONT_FACE_CW"; + default: + return "Unhandled XGL_FACE_ORIENTATION"; } } diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h index 27df254..4a0f032 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h @@ -3,18 +3,12 @@ #include -static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) +static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) { - switch ((XGL_STENCIL_OP)input_value) + switch ((XGL_PIPELINE_BIND_POINT)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_PIPELINE_BIND_POINT_COMPUTE: + case XGL_PIPELINE_BIND_POINT_GRAPHICS: return 1; default: return 0; @@ -22,15 +16,16 @@ static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) } -static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) +static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) { - switch ((XGL_SYSTEM_ALLOC_TYPE)input_value) + switch ((XGL_PIPELINE_SHADER_STAGE)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_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; @@ -38,11 +33,11 @@ static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE inpu } -static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) +static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) { - switch ((XGL_MEMORY_REF_FLAGS)input_value) + switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) { - case XGL_MEMORY_REF_READ_ONLY_BIT: + case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: return 1; default: return 0; @@ -50,12 +45,13 @@ static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_ } -static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value) +static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) { - switch ((XGL_PIPELINE_BIND_POINT)input_value) + switch ((XGL_MEMORY_TYPE)input_value) { - case XGL_PIPELINE_BIND_POINT_COMPUTE: - case XGL_PIPELINE_BIND_POINT_GRAPHICS: + case XGL_MEMORY_TYPE_BUFFER: + case XGL_MEMORY_TYPE_IMAGE: + case XGL_MEMORY_TYPE_OTHER: return 1; default: return 0; @@ -63,15 +59,16 @@ static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT } -static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) +static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) { - switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value) + switch ((XGL_CHANNEL_SWIZZLE)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_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; @@ -79,13 +76,12 @@ static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS } -static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value) +static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) { - switch ((XGL_ATTACHMENT_STORE_OP)input_value) + switch ((XGL_DEPTH_MODE)input_value) { - case XGL_ATTACHMENT_STORE_OP_DONT_CARE: - case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA: - case XGL_ATTACHMENT_STORE_OP_STORE: + case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: + case XGL_DEPTH_MODE_ZERO_TO_ONE: return 1; default: return 0; @@ -93,14 +89,177 @@ static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP } -static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) +static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value) { - switch ((XGL_OBJECT_INFO_TYPE)input_value) + switch ((XGL_FORMAT)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_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; @@ -108,16 +267,12 @@ static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_ } -static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value) +static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) { - switch ((XGL_CHANNEL_SWIZZLE)input_value) + switch ((XGL_BUFFER_CREATE_FLAGS)input_value) { - case XGL_CHANNEL_SWIZZLE_A: - case XGL_CHANNEL_SWIZZLE_B: - case XGL_CHANNEL_SWIZZLE_G: - case XGL_CHANNEL_SWIZZLE_ONE: - case XGL_CHANNEL_SWIZZLE_R: - case XGL_CHANNEL_SWIZZLE_ZERO: + case XGL_BUFFER_CREATE_SHAREABLE_BIT: + case XGL_BUFFER_CREATE_SPARSE_BIT: return 1; default: return 0; @@ -125,11 +280,17 @@ static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_va } -static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) { - switch ((XGL_PIPELINE_CREATE_FLAGS)input_value) + switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value) { - case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: + 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; @@ -137,12 +298,40 @@ static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FL } -static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) { - switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value) + switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) { - case XGL_DESCRIPTOR_UDPATE_MODE_COPY: - case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST: + 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; @@ -171,28 +360,15 @@ static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS inpu } -static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) +static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value) { - switch ((XGL_IMAGE_FORMAT_CLASS)input_value) + switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value) { - case XGL_IMAGE_FORMAT_CLASS_128_BITS: - case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK: - case XGL_IMAGE_FORMAT_CLASS_16_BITS: - case XGL_IMAGE_FORMAT_CLASS_24_BITS: - case XGL_IMAGE_FORMAT_CLASS_32_BITS: - case XGL_IMAGE_FORMAT_CLASS_48_BITS: - case XGL_IMAGE_FORMAT_CLASS_64_BITS: - case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK: - case XGL_IMAGE_FORMAT_CLASS_8_BITS: - case XGL_IMAGE_FORMAT_CLASS_96_BITS: - case XGL_IMAGE_FORMAT_CLASS_D16: - case XGL_IMAGE_FORMAT_CLASS_D16S8: - case XGL_IMAGE_FORMAT_CLASS_D24: - case XGL_IMAGE_FORMAT_CLASS_D24S8: - case XGL_IMAGE_FORMAT_CLASS_D32: - case XGL_IMAGE_FORMAT_CLASS_D32S8: - case XGL_IMAGE_FORMAT_CLASS_LINEAR: - case XGL_IMAGE_FORMAT_CLASS_S8: + case XGL_MEMORY_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; @@ -200,12 +376,64 @@ static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS in } -static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) +static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value) { - switch ((XGL_QUERY_TYPE)input_value) + switch ((XGL_SET_EVENT)input_value) { - case XGL_QUERY_OCCLUSION: - case XGL_QUERY_PIPELINE_STATISTICS: + 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; @@ -279,15 +507,11 @@ static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_valu } -static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value) { - switch ((XGL_IMAGE_CREATE_FLAGS)input_value) + switch ((XGL_MEMORY_REF_FLAGS)input_value) { - case XGL_IMAGE_CREATE_CLONEABLE_BIT: - case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT: - case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT: - case XGL_IMAGE_CREATE_SHAREABLE_BIT: - case XGL_IMAGE_CREATE_SPARSE_BIT: + case XGL_MEMORY_REF_READ_ONLY_BIT: return 1; default: return 0; @@ -295,19 +519,12 @@ static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS in } -static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value) +static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value) { - switch ((XGL_MEMORY_INPUT_FLAGS)input_value) + switch ((XGL_DESCRIPTOR_SET_USAGE)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_DESCRIPTOR_SET_USAGE_ONE_SHOT: + case XGL_DESCRIPTOR_SET_USAGE_STATIC: return 1; default: return 0; @@ -315,13 +532,11 @@ static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS in } -static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) +static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) { - switch ((XGL_IMAGE_ASPECT)input_value) + switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) { - case XGL_IMAGE_ASPECT_COLOR: - case XGL_IMAGE_ASPECT_DEPTH: - case XGL_IMAGE_ASPECT_STENCIL: + case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: return 1; default: return 0; @@ -329,12 +544,12 @@ static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) } -static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) { - switch ((XGL_DEVICE_CREATE_FLAGS)input_value) + switch ((XGL_WAIT_EVENT)input_value) { - case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT: - case XGL_DEVICE_CREATE_VALIDATION_BIT: + case XGL_WAIT_EVENT_BEFORE_RASTERIZATION: + case XGL_WAIT_EVENT_TOP_OF_PIPE: return 1; default: return 0; @@ -342,18 +557,14 @@ static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS } -static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) +static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) { - switch ((XGL_COMPARE_FUNC)input_value) + switch ((XGL_QUEUE_FLAGS)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_QUEUE_COMPUTE_BIT: + case XGL_QUEUE_DMA_BIT: + case XGL_QUEUE_EXTENDED_BIT: + case XGL_QUEUE_GRAPHICS_BIT: return 1; default: return 0; @@ -361,17 +572,15 @@ static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) } -static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) +static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value) { - switch ((XGL_SHADER_STAGE_FLAGS)input_value) + switch ((XGL_SYSTEM_ALLOC_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_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; @@ -379,13 +588,15 @@ static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS in } -static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value) +static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) { - switch ((XGL_FILL_MODE)input_value) + switch ((XGL_VALIDATION_LEVEL)input_value) { - case XGL_FILL_POINTS: - case XGL_FILL_SOLID: - case XGL_FILL_WIREFRAME: + 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; @@ -393,12 +604,14 @@ static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value) } -static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value) +static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) { - switch ((XGL_COORDINATE_ORIGIN)input_value) + switch ((XGL_PHYSICAL_GPU_TYPE)input_value) { - case XGL_COORDINATE_ORIGIN_LOWER_LEFT: - case XGL_COORDINATE_ORIGIN_UPPER_LEFT: + 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; @@ -406,12 +619,18 @@ static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN inpu } -static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) +static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) { - switch ((XGL_WAIT_EVENT)input_value) + switch ((XGL_IMAGE_LAYOUT)input_value) { - case XGL_WAIT_EVENT_BEFORE_RASTERIZATION: - case XGL_WAIT_EVENT_TOP_OF_PIPE: + 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; @@ -419,51 +638,29 @@ static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value) } -static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value) +static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value) { - switch ((XGL_DESCRIPTOR_TYPE)input_value) + switch ((XGL_BLEND)input_value) { - case XGL_DESCRIPTOR_TYPE_IMAGE: - case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER: - case XGL_DESCRIPTOR_TYPE_RAW_BUFFER: - case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC: - case XGL_DESCRIPTOR_TYPE_SAMPLER: - case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE: - case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER: - case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC: - case XGL_DESCRIPTOR_TYPE_TEXTURE: - case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER: - case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value) -{ - switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value) - { - case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) -{ - switch ((XGL_MEMORY_PRIORITY)input_value) - { - case XGL_MEMORY_PRIORITY_HIGH: - case XGL_MEMORY_PRIORITY_LOW: - case XGL_MEMORY_PRIORITY_NORMAL: - case XGL_MEMORY_PRIORITY_UNUSED: - case XGL_MEMORY_PRIORITY_VERY_HIGH: - case XGL_MEMORY_PRIORITY_VERY_LOW: + 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; @@ -471,12 +668,13 @@ static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_va } -static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) +static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) { - switch ((XGL_TIMESTAMP_TYPE)input_value) + switch ((XGL_QUEUE_TYPE)input_value) { - case XGL_TIMESTAMP_BOTTOM: - case XGL_TIMESTAMP_TOP: + case XGL_QUEUE_TYPE_COMPUTE: + case XGL_QUEUE_TYPE_DMA: + case XGL_QUEUE_TYPE_GRAPHICS: return 1; default: return 0; @@ -484,14 +682,17 @@ static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_valu } -static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value) +static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value) { - switch ((XGL_PHYSICAL_GPU_TYPE)input_value) + switch ((XGL_SHADER_STAGE_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_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; @@ -521,501 +722,14 @@ static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY in return 0; } } - - -static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value) -{ - switch ((XGL_IMAGE_VIEW_TYPE)input_value) - { - case XGL_IMAGE_VIEW_1D: - case XGL_IMAGE_VIEW_2D: - case XGL_IMAGE_VIEW_3D: - case XGL_IMAGE_VIEW_CUBE: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value) -{ - switch ((XGL_DESCRIPTOR_SET_USAGE)input_value) - { - case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT: - case XGL_DESCRIPTOR_SET_USAGE_STATIC: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) -{ - switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) - { - case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value) -{ - switch ((XGL_RESULT)input_value) - { - case XGL_ERROR_BAD_PIPELINE_DATA: - case XGL_ERROR_BAD_SHADER_CODE: - case XGL_ERROR_BUILDING_COMMAND_BUFFER: - case XGL_ERROR_DEVICE_ALREADY_CREATED: - case XGL_ERROR_DEVICE_LOST: - case XGL_ERROR_INCOMPATIBLE_DEVICE: - case XGL_ERROR_INCOMPATIBLE_DRIVER: - case XGL_ERROR_INCOMPATIBLE_QUEUE: - case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER: - case XGL_ERROR_INITIALIZATION_FAILED: - case XGL_ERROR_INVALID_ALIGNMENT: - case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA: - case XGL_ERROR_INVALID_EXTENSION: - case XGL_ERROR_INVALID_FLAGS: - case XGL_ERROR_INVALID_FORMAT: - case XGL_ERROR_INVALID_HANDLE: - case XGL_ERROR_INVALID_IMAGE: - case XGL_ERROR_INVALID_MEMORY_SIZE: - case XGL_ERROR_INVALID_OBJECT_TYPE: - case XGL_ERROR_INVALID_ORDINAL: - case XGL_ERROR_INVALID_POINTER: - case XGL_ERROR_INVALID_QUEUE_TYPE: - case XGL_ERROR_INVALID_VALUE: - case XGL_ERROR_MEMORY_MAP_FAILED: - case XGL_ERROR_MEMORY_NOT_BOUND: - case XGL_ERROR_MEMORY_UNMAP_FAILED: - case XGL_ERROR_NOT_MAPPABLE: - case XGL_ERROR_NOT_SHAREABLE: - case XGL_ERROR_OUT_OF_GPU_MEMORY: - case XGL_ERROR_OUT_OF_MEMORY: - case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES: - case XGL_ERROR_UNAVAILABLE: - case XGL_ERROR_UNKNOWN: - case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION: - case XGL_EVENT_RESET: - case XGL_EVENT_SET: - case XGL_NOT_READY: - case XGL_SUCCESS: - case XGL_TIMEOUT: - case XGL_UNSUPPORTED: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) -{ - switch ((XGL_BORDER_COLOR_TYPE)input_value) - { - case XGL_BORDER_COLOR_OPAQUE_BLACK: - case XGL_BORDER_COLOR_OPAQUE_WHITE: - case XGL_BORDER_COLOR_TRANSPARENT_BLACK: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) -{ - switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value) - { - case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES: - case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE: - case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES: - case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) -{ - switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) - { - case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT: - case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) -{ - switch ((XGL_INDEX_TYPE)input_value) - { - case XGL_INDEX_16: - case XGL_INDEX_32: - case XGL_INDEX_8: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value) -{ - switch ((XGL_CULL_MODE)input_value) - { - case XGL_CULL_BACK: - case XGL_CULL_FRONT: - case XGL_CULL_FRONT_AND_BACK: - case XGL_CULL_NONE: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value) -{ - switch ((XGL_SET_EVENT)input_value) - { - case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE: - case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE: - case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE: - case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE: - case XGL_SET_EVENT_TOP_OF_PIPE: - case XGL_SET_EVENT_TRANSFER_COMPLETE: - case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value) -{ - switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value) - { - case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT: - case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT: - case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT: - case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT: - case XGL_MEMORY_PROPERTY_GPU_ONLY: - case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL: - case XGL_MEMORY_PROPERTY_SHAREABLE_BIT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) -{ - switch ((XGL_ATTACHMENT_LOAD_OP)input_value) - { - case XGL_ATTACHMENT_LOAD_OP_CLEAR: - case XGL_ATTACHMENT_LOAD_OP_DONT_CARE: - case XGL_ATTACHMENT_LOAD_OP_LOAD: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) -{ - switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value) - { - case XGL_PROVOKING_VERTEX_FIRST: - case XGL_PROVOKING_VERTEX_LAST: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value) -{ - switch ((XGL_VALIDATION_LEVEL)input_value) - { - case XGL_VALIDATION_LEVEL_0: - case XGL_VALIDATION_LEVEL_1: - case XGL_VALIDATION_LEVEL_2: - case XGL_VALIDATION_LEVEL_3: - case XGL_VALIDATION_LEVEL_4: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) -{ - switch ((XGL_FACE_ORIENTATION)input_value) - { - case XGL_FRONT_FACE_CCW: - case XGL_FRONT_FACE_CW: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value) -{ - switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value) - { - case XGL_VERTEX_INPUT_STEP_RATE_DRAW: - case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE: - case XGL_VERTEX_INPUT_STEP_RATE_VERTEX: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value) -{ - switch ((XGL_QUEUE_FLAGS)input_value) - { - case XGL_QUEUE_COMPUTE_BIT: - case XGL_QUEUE_DMA_BIT: - case XGL_QUEUE_EXTENDED_BIT: - case XGL_QUEUE_GRAPHICS_BIT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value) -{ - switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value) - { - case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC: - case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value) -{ - switch ((XGL_TEX_MIPMAP_MODE)input_value) - { - case XGL_TEX_MIPMAP_BASE: - case XGL_TEX_MIPMAP_LINEAR: - case XGL_TEX_MIPMAP_NEAREST: - return 1; - default: - return 0; - } -} - - -static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) -{ - switch ((XGL_QUERY_CONTROL_FLAGS)input_value) - { - case XGL_QUERY_IMPRECISE_DATA_BIT: - 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: - 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_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value) +{ + switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value) + { + case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT: + case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT: return 1; default: return 0; @@ -1023,12 +737,67 @@ static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value) } -static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value) +static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) { - switch ((XGL_DEPTH_MODE)input_value) + switch ((XGL_IMAGE_TILING)input_value) { - case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: - case XGL_DEPTH_MODE_ZERO_TO_ONE: + case XGL_LINEAR_TILING: + case XGL_OPTIMAL_TILING: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value) +{ + switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value) + { + case XGL_VERTEX_INPUT_STEP_RATE_DRAW: + case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE: + case XGL_VERTEX_INPUT_STEP_RATE_VERTEX: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value) +{ + switch ((XGL_DEVICE_CREATE_FLAGS)input_value) + { + case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT: + case XGL_DEVICE_CREATE_VALIDATION_BIT: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value) +{ + switch ((XGL_OBJECT_INFO_TYPE)input_value) + { + case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS: + case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS: + case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT: + case XGL_INFO_TYPE_MEMORY_REQUIREMENTS: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value) +{ + switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value) + { + case XGL_PROVOKING_VERTEX_FIRST: + case XGL_PROVOKING_VERTEX_LAST: return 1; default: return 0; @@ -1050,6 +819,29 @@ 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) +{ + switch ((XGL_DESCRIPTOR_TYPE)input_value) + { + case XGL_DESCRIPTOR_TYPE_IMAGE: + case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER: + case XGL_DESCRIPTOR_TYPE_RAW_BUFFER: + case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC: + case XGL_DESCRIPTOR_TYPE_SAMPLER: + case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE: + case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER: + case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC: + case XGL_DESCRIPTOR_TYPE_TEXTURE: + case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER: + case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + return 1; + default: + return 0; + } +} + + static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) { switch ((XGL_IMAGE_TYPE)input_value) @@ -1064,29 +856,141 @@ static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value) } -static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value) +static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) { - switch ((XGL_BLEND)input_value) + switch ((XGL_BLEND_FUNC)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_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_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) +{ + switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) + { + case XGL_GPU_COMPAT_ASIC_FEATURES_BIT: + case XGL_GPU_COMPAT_IQ_MATCH_BIT: + case XGL_GPU_COMPAT_PEER_TRANSFER_BIT: + case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT: + case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT: + case XGL_GPU_COMPAT_SHARED_MEMORY_BIT: + case XGL_GPU_COMPAT_SHARED_SYNC_BIT: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value) +{ + switch ((XGL_MEMORY_PRIORITY)input_value) + { + case XGL_MEMORY_PRIORITY_HIGH: + case XGL_MEMORY_PRIORITY_LOW: + case XGL_MEMORY_PRIORITY_NORMAL: + case XGL_MEMORY_PRIORITY_UNUSED: + case XGL_MEMORY_PRIORITY_VERY_HIGH: + case XGL_MEMORY_PRIORITY_VERY_LOW: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_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_FILL_MODE(XGL_FILL_MODE input_value) +{ + switch ((XGL_FILL_MODE)input_value) + { + case XGL_FILL_POINTS: + case XGL_FILL_SOLID: + case XGL_FILL_WIREFRAME: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) +{ + switch ((XGL_TEX_FILTER)input_value) + { + case XGL_TEX_FILTER_LINEAR: + case XGL_TEX_FILTER_NEAREST: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value) +{ + switch ((XGL_QUERY_TYPE)input_value) + { + case XGL_QUERY_OCCLUSION: + case XGL_QUERY_PIPELINE_STATISTICS: return 1; default: return 0; @@ -1115,12 +1019,12 @@ static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAG } -static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) +static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value) { - switch ((XGL_TEX_FILTER)input_value) + switch ((XGL_TIMESTAMP_TYPE)input_value) { - case XGL_TEX_FILTER_LINEAR: - case XGL_TEX_FILTER_NEAREST: + case XGL_TIMESTAMP_BOTTOM: + case XGL_TIMESTAMP_TOP: return 1; default: return 0; @@ -1128,16 +1032,13 @@ static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value) } -static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value) +static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value) { - switch ((XGL_PIPELINE_SHADER_STAGE)input_value) + switch ((XGL_BORDER_COLOR_TYPE)input_value) { - case XGL_SHADER_STAGE_COMPUTE: - 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_BORDER_COLOR_OPAQUE_BLACK: + case XGL_BORDER_COLOR_OPAQUE_WHITE: + case XGL_BORDER_COLOR_TRANSPARENT_BLACK: return 1; default: return 0; @@ -1145,15 +1046,26 @@ static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_ST } -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; @@ -1161,18 +1073,11 @@ static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value) } -static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) +static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value) { - switch ((XGL_IMAGE_LAYOUT)input_value) + switch ((XGL_QUERY_CONTROL_FLAGS)input_value) { - case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL: - case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: - case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: - case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: - case XGL_IMAGE_LAYOUT_GENERAL: - case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: - case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL: - case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL: + case XGL_QUERY_IMPRECISE_DATA_BIT: return 1; default: return 0; @@ -1180,12 +1085,13 @@ static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value) } -static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value) +static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value) { - switch ((XGL_BUFFER_CREATE_FLAGS)input_value) + switch ((XGL_IMAGE_ASPECT)input_value) { - case XGL_BUFFER_CREATE_SHAREABLE_BIT: - case XGL_BUFFER_CREATE_SPARSE_BIT: + case XGL_IMAGE_ASPECT_COLOR: + case XGL_IMAGE_ASPECT_DEPTH: + case XGL_IMAGE_ASPECT_STENCIL: return 1; default: return 0; @@ -1193,13 +1099,13 @@ static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS } -static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) +static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value) { - switch ((XGL_MEMORY_TYPE)input_value) + switch ((XGL_ATTACHMENT_LOAD_OP)input_value) { - case XGL_MEMORY_TYPE_BUFFER: - case XGL_MEMORY_TYPE_IMAGE: - case XGL_MEMORY_TYPE_OTHER: + case XGL_ATTACHMENT_LOAD_OP_CLEAR: + case XGL_ATTACHMENT_LOAD_OP_DONT_CARE: + case XGL_ATTACHMENT_LOAD_OP_LOAD: return 1; default: return 0; @@ -1207,13 +1113,28 @@ static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value) } -static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) +static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value) { - switch ((XGL_QUEUE_TYPE)input_value) + switch ((XGL_IMAGE_FORMAT_CLASS)input_value) { - case XGL_QUEUE_TYPE_COMPUTE: - case XGL_QUEUE_TYPE_DMA: - case XGL_QUEUE_TYPE_GRAPHICS: + 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; @@ -1221,12 +1142,15 @@ static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value) } -static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value) +static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) { - switch ((XGL_IMAGE_TILING)input_value) + switch ((XGL_TEX_ADDRESS)input_value) { - case XGL_LINEAR_TILING: - case XGL_OPTIMAL_TILING: + 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; @@ -1249,11 +1173,32 @@ static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_ } -static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) +static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value) { - switch ((XGL_FORMAT_INFO_TYPE)input_value) + switch ((XGL_INDEX_TYPE)input_value) { - case XGL_INFO_TYPE_FORMAT_PROPERTIES: + case XGL_INDEX_16: + case XGL_INDEX_32: + case XGL_INDEX_8: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value) +{ + switch ((XGL_COMPARE_FUNC)input_value) + { + case XGL_COMPARE_ALWAYS: + case XGL_COMPARE_EQUAL: + case XGL_COMPARE_GREATER: + case XGL_COMPARE_GREATER_EQUAL: + case XGL_COMPARE_LESS: + case XGL_COMPARE_LESS_EQUAL: + case XGL_COMPARE_NEVER: + case XGL_COMPARE_NOT_EQUAL: return 1; default: return 0; @@ -1276,15 +1221,18 @@ static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_ } -static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) +static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value) { - switch ((XGL_TEX_ADDRESS)input_value) + switch ((XGL_STENCIL_OP)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_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; @@ -1292,17 +1240,44 @@ static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value) } -static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value) +static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value) { - switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value) + switch ((XGL_PHYSICAL_GPU_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_PHYSICAL_GPU_MEMORY_PROPERTIES: + case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE: + case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES: + case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value) +{ + switch ((XGL_IMAGE_CREATE_FLAGS)input_value) + { + case XGL_IMAGE_CREATE_CLONEABLE_BIT: + case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT: + case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT: + case XGL_IMAGE_CREATE_SHAREABLE_BIT: + case XGL_IMAGE_CREATE_SPARSE_BIT: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value) +{ + switch ((XGL_ATTACHMENT_STORE_OP)input_value) + { + case XGL_ATTACHMENT_STORE_OP_DONT_CARE: + case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA: + case XGL_ATTACHMENT_STORE_OP_STORE: return 1; default: return 0; @@ -1335,26 +1310,51 @@ static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS in } -static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value) +static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value) { - switch ((XGL_LOGIC_OP)input_value) + switch ((XGL_IMAGE_VIEW_TYPE)input_value) { - case XGL_LOGIC_OP_AND: - case XGL_LOGIC_OP_AND_INVERTED: - case XGL_LOGIC_OP_AND_REVERSE: - case XGL_LOGIC_OP_CLEAR: - case XGL_LOGIC_OP_COPY: - case XGL_LOGIC_OP_COPY_INVERTED: - case XGL_LOGIC_OP_EQUIV: - case XGL_LOGIC_OP_INVERT: - case XGL_LOGIC_OP_NAND: - case XGL_LOGIC_OP_NOOP: - case XGL_LOGIC_OP_NOR: - case XGL_LOGIC_OP_OR: - case XGL_LOGIC_OP_OR_INVERTED: - case XGL_LOGIC_OP_OR_REVERSE: - case XGL_LOGIC_OP_SET: - case XGL_LOGIC_OP_XOR: + case XGL_IMAGE_VIEW_1D: + case XGL_IMAGE_VIEW_2D: + case XGL_IMAGE_VIEW_3D: + case XGL_IMAGE_VIEW_CUBE: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value) +{ + switch ((XGL_FORMAT_INFO_TYPE)input_value) + { + case XGL_INFO_TYPE_FORMAT_PROPERTIES: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value) +{ + switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value) + { + case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT: + return 1; + default: + return 0; + } +} + + +static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value) +{ + switch ((XGL_FACE_ORIENTATION)input_value) + { + case XGL_FRONT_FACE_CCW: + case XGL_FRONT_FACE_CW: return 1; default: return 0; diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h index 3ce093b..2c92755 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h @@ -6,966 +6,966 @@ // Function Prototypes size_t get_struct_chain_size(const void* pStruct); size_t get_dynamic_struct_size(const void* pStruct); -size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct); -size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct); -size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct); -size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct); -size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct); -size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct); -size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct); -size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct); -size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct); -size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct); -size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct); -size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct); -size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct); +size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* 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_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* 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_image_resolve(const XGL_IMAGE_RESOLVE* pStruct); -size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct); -size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_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_buffer_copy(const XGL_BUFFER_COPY* pStruct); -size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct); -size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct); -size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct); +size_t xgl_size_xgl_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_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct); -size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct); -size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct); -size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct); -size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct); -size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct); -size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct); -size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct); +size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct); +size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct); +size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct); size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct); +size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct); +size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct); +size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct); +size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct); +size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct); size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct); -size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct); -size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct); -size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct); -size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct); size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct); -size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct); -size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct); -size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct); -size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct); +size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct); size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct); +size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct); +size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_rect(const XGL_RECT* pStruct); +size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct); +size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct); +size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct); size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct); -size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct); -size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct); -size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct); -size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct); -size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct); -size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct); -size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct); -size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct); +size_t xgl_size_xgl_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_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct); -size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct); -size_t xgl_size_xgl_rect(const XGL_RECT* pStruct); -size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct); +size_t xgl_size_xgl_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_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* 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_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct); -size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct); -size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct); -size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct); -size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct); -size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct); -size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct); -size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct); -size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct); -size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct); -size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct); +size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct); +size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct); +size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct); +size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct); +size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct); size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct); +size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct); +size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct); size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct); +size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct); +size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct); +size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct); +size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct); +size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct); +size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct); +size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct); +size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct); +size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct); +size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct); +size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct); +size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct); +size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct); +size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct); +size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct); +size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct); size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct); -size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct); -size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct); -size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct); -size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct); -size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct); -size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct); -size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct); size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct); -size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct); -size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct); -size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct); -size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct); -size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct); -size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct); +size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct); +size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct); +size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct); +size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct); +size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct); +size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct); +size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct); +size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct); +size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct); +size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct); +size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct); +size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct); -size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct) +size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_FORMAT_PROPERTIES); + structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct) +size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_BUFFER_IMAGE_COPY); + structSize = sizeof(XGL_APPLICATION_INFO); + structSize += sizeof(char)*(1+strlen(pStruct->pAppName)); + structSize += sizeof(char)*(1+strlen(pStruct->pEngineName)); } return structSize; } -size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct) +size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO); + structSize = sizeof(XGL_LINK_CONST_BUFFER); + structSize += pStruct->bufferSize; } return structSize; } -size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct) +size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_SUBRESOURCE_LAYOUT); + structSize = sizeof(XGL_UPDATE_SAMPLERS); + structSize += pStruct->count*sizeof(XGL_SAMPLER); } return structSize; } -size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct) +size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES); + structSize = sizeof(XGL_STENCIL_OP_STATE); } return structSize; } -size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* 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_SAMPLER_CREATE_INFO); + structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO); } return structSize; } -size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct) +size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD); + 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_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct) +size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_UPDATE_AS_COPY); + structSize = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS); } return structSize; } -size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct) +size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_CLEAR_COLOR); + 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_extent2d(const XGL_EXTENT2D* 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_EXTENT2D); + structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION); } return structSize; } -size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* 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_FRAMEBUFFER_CREATE_INFO); + structSize = sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO); uint32_t i = 0; - for (i = 0; i < pStruct->colorAttachmentCount; i++) { - structSize += xgl_size_xgl_color_attachment_bind_info(&pStruct->pColorAttachments[i]); + 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 += xgl_size_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment); } return structSize; } -size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct) +size_t 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_ALLOC_CALLBACKS); + structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct) +size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_MEMORY_REQUIREMENTS); + structSize = sizeof(XGL_SUBRESOURCE_LAYOUT); } return structSize; } -size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* 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_LINK_CONST_BUFFER); - structSize += pStruct->bufferSize; + structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD); } return structSize; } -size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* 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_PHYSICAL_GPU_PROPERTIES); + 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_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct) +size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* 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_SHADER_CREATE_INFO); + structSize += pStruct->codeSize; } return structSize; } -size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct) +size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_IMAGE_RESOLVE); + structSize = sizeof(XGL_MEMORY_REF); } return structSize; } -size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct) +size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO); + structSize = sizeof(XGL_FORMAT_PROPERTIES); } return structSize; } -size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct) +size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_FENCE_CREATE_INFO); + structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA); } 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_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO); + structSize = sizeof(XGL_ALLOC_CALLBACKS); } return structSize; } -size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* 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_BUFFER_COPY); + 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_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_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_COLOR_ATTACHMENT_BIND_INFO); + structSize = sizeof(XGL_DRAW_INDIRECT_CMD); } return structSize; } -size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct) +size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO); + structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* 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_QUEUE_SEMAPHORE_OPEN_INFO); + structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE); } 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_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO); - uint32_t i = 0; - for (i = 0; i < pStruct->attachmentCount; i++) { - structSize += xgl_size_xgl_pipeline_cb_attachment_state(&pStruct->pAttachments[i]); - } + structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION); } 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_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO); + structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct) +size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS); + structSize = sizeof(XGL_FENCE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_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_SAMPLER_IMAGE_VIEW_INFO); - structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView); + 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_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct) +size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO); + structSize = sizeof(XGL_EXTENT2D); } return structSize; } -size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* 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_EVENT_WAIT_INFO); - structSize += pStruct->eventCount*sizeof(XGL_EVENT); - structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER)); + structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct) +size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* 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_IMAGE_SUBRESOURCE_RANGE); } return structSize; } -size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_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_MEMORY_ALLOC_INFO); + structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct) +size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_MEMORY_OPEN_INFO); + structSize = sizeof(XGL_OFFSET2D); } return structSize; } -size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* 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_GRAPHICS_PIPELINE_CREATE_INFO); + structSize = sizeof(XGL_QUEUE_SEMAPHORE_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_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO); + structSize = sizeof(XGL_CLEAR_COLOR_VALUE); } 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_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO); + structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER); } return structSize; } -size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* 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_PIPELINE_BARRIER); - structSize += pStruct->eventCount*sizeof(XGL_SET_EVENT); - structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER)); + structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* 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_MEMORY_BARRIER); + structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_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_PIPELINE_IA_STATE_CREATE_INFO); + structSize = sizeof(XGL_IMAGE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct) +size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE); + 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_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* 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_CMD_BUFFER_CREATE_INFO); + structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO); } return structSize; } -size_t xgl_size_xgl_application_info(const XGL_APPLICATION_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_APPLICATION_INFO); - structSize += sizeof(char)*(1+strlen(pStruct->pAppName)); - structSize += sizeof(char)*(1+strlen(pStruct->pEngineName)); + structSize = sizeof(XGL_IMAGE_VIEW_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_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO); + structSize = sizeof(XGL_GRAPHICS_PIPELINE_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_rect(const XGL_RECT* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO); + structSize = sizeof(XGL_RECT); } return structSize; } -size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_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_IMAGE_MEMORY_BIND_INFO); + structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO); } return structSize; } -size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* 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_IMAGE_SUBRESOURCE); + structSize = sizeof(XGL_DEVICE_QUEUE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct) +size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DRAW_INDIRECT_CMD); + structSize = sizeof(XGL_MEMORY_OPEN_INFO); } return structSize; } -size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_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_IMAGE_VIEW_CREATE_INFO); + structSize = sizeof(XGL_UPDATE_AS_COPY); } return structSize; } -size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct) +size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO); + structSize = sizeof(XGL_IMAGE_COPY); } return structSize; } -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 structSize = 0; if (pStruct) { - structSize = sizeof(XGL_IMAGE_COPY); + structSize = sizeof(XGL_IMAGE_RESOLVE); } 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_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO); + structSize = sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO); } return structSize; } -size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* 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_IMAGE_MEMORY_BARRIER); + structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct) +size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES); + structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER); } return structSize; } -size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* 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_MEMORY_ALLOC_BUFFER_INFO); + structSize = sizeof(XGL_PIPELINE_DS_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_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_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_channel_mapping(const XGL_CHANNEL_MAPPING* 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_CHANNEL_MAPPING); + structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES); } return structSize; } -size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* 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_PEER_IMAGE_OPEN_INFO); + structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_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_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO); + structSize = sizeof(XGL_UPDATE_SAMPLER_TEXTURES); 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]); + 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_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* 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_PHYSICAL_GPU_PERFORMANCE); + structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO); } return structSize; } -size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_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_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_DESCRIPTOR_TYPE_COUNT); } return structSize; } -size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct) +size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_VIEWPORT); + structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD); } 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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO); + structSize = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO); + uint32_t i = 0; + for (i = 0; i < pStruct->count; i++) { + structSize += xgl_size_xgl_descriptor_type_count(&pStruct->pTypeCount[i]); + } } return structSize; } -size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct) +size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_BUFFER_CREATE_INFO); + structSize = sizeof(XGL_VIEWPORT); } 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_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO); + structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_rect(const XGL_RECT* 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_RECT); + structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* 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_BUFFER_MEMORY_BARRIER); + structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO); } 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_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO); + structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO); } 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_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* 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_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_QUEUE_SEMAPHORE_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_memory_barrier(const XGL_MEMORY_BARRIER* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO); + structSize = sizeof(XGL_MEMORY_BARRIER); } return structSize; } -size_t xgl_size_xgl_event_create_info(const XGL_EVENT_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_EVENT_CREATE_INFO); + structSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE); } return structSize; } -size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct) +size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_OFFSET2D); + structSize = sizeof(XGL_CHANNEL_MAPPING); } return structSize; } -size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct) +size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* 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_CLEAR_COLOR); } return structSize; } -size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* 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_MEMORY_REF); + structSize = sizeof(XGL_DYNAMIC_CB_STATE_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_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO); + structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO); } 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_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* 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_SAMPLER_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_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_GPU_COMPATIBILITY_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_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct) +size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_SHADER_CREATE_INFO); - structSize += pStruct->codeSize; + structSize = sizeof(XGL_BUFFER_IMAGE_COPY); } return structSize; } -size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct) +size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_OFFSET3D); + structSize = sizeof(XGL_EVENT_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_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_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_PHYSICAL_GPU_PROPERTIES); } 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_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO); + structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO); } return structSize; } -size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_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_DEPTH_STENCIL_BIND_INFO); + structSize = sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO); } return structSize; } -size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct) +size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS); + structSize = sizeof(XGL_BUFFER_COPY); } return structSize; } -size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* 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_IMAGE_SUBRESOURCE_RANGE); + structSize = sizeof(XGL_IMAGE_MEMORY_BIND_INFO); } return structSize; } -size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct) +size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* 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_IMAGE_MEMORY_REQUIREMENTS); } return structSize; } -size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct) +size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD); + 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_extent3d(const XGL_EXTENT3D* pStruct) +size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_EXTENT3D); + structSize = sizeof(XGL_OFFSET3D); } return structSize; } -size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* 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_CLEAR_COLOR_VALUE); + structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO); } return structSize; } -size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct) +size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO); + structSize = sizeof(XGL_EXTENT3D); } return structSize; } -size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_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_DEVICE_QUEUE_CREATE_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_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct) +size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_STENCIL_OP_STATE); + structSize = sizeof(XGL_IMAGE_SUBRESOURCE); } return structSize; } -size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct) +size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_SHADER); + structSize = sizeof(XGL_LAYER_CREATE_INFO); 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->layerCount; i++) { + structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppActiveLayerNames[i])))); } } return structSize; } -size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct) +size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO); + structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct) +size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA); + structSize = sizeof(XGL_BUFFER_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_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION); + structSize = sizeof(XGL_RENDER_PASS_CREATE_INFO); + structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP); + structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP); + uint32_t i = 0; + for (i = 0; i < pStruct->colorAttachmentCount; i++) { + structSize += xgl_size_xgl_clear_color(&pStruct->pColorLoadClearValues[i]); + } } return structSize; } -size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* 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_VERTEX_INPUT_BINDING_DESCRIPTION); + structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO); } return structSize; } -size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* 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_SAMPLERS); - structSize += pStruct->count*sizeof(XGL_SAMPLER); + structSize = sizeof(XGL_GPU_COMPATIBILITY_INFO); } return structSize; } -size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct) +size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_IMAGE_CREATE_INFO); + structSize = sizeof(XGL_MEMORY_ALLOC_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_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct) { size_t structSize = 0; if (pStruct) { - structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO); + structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES); } return structSize; } diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h index b6568c4..7cf0102 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h @@ -115,49 +115,7 @@ char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix); #define snprintf _snprintf #endif // _WIN32 -char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures)); - return str; -} -char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix) -{ - char* str; - size_t len; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[3]; - tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %simageSubresource (%p)\n%s", prefix, (void*)&pStruct->imageSubresource, tmpStr); - tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %simageOffset (%p)\n%s", prefix, (void*)&pStruct->imageOffset, tmpStr); - tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[2] = (char*)malloc(len); - snprintf(stp_strs[2], len, " %simageExtent (%p)\n%s", prefix, (void*)&pStruct->imageExtent, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sbufferOffset = %p\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (void*)(pStruct->bufferOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent)); - for (int32_t stp_index = 2; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } - } - free(extra_indent); - return str; -} -char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -177,7 +135,7 @@ char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* 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%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem)); + snprintf(str, len, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -187,25 +145,7 @@ char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStru 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_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE"); - return str; -} -char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -225,7 +165,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%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -235,16 +175,16 @@ char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, free(extra_indent); return str; } -char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* 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, "%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, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData)); return str; } -char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix) +char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix) { char* str; size_t len; @@ -264,7 +204,7 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* 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%sdescriptorType = %s\n%sdescriptorSet = %p\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->descriptorIndex), prefix, (pStruct->count)); + snprintf(str, len, "%ssType = %s\n%spNext = %p\n%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])); @@ -274,41 +214,25 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char free(extra_indent); return str; } -char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* 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; - 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; + len = sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%scolor = %p\n%suseRawValue = %s\n", prefix, (void*)&(pStruct->color), prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE"); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } - } - free(extra_indent); + 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_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix) +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, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height)); + snprintf(str, len, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage)); return str; } -char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_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; @@ -316,7 +240,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); @@ -326,26 +250,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->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, " %spColorAttachments (%p)\n%s", prefix, (void*)pStruct->pColorAttachments, tmpStr); + snprintf(stp_strs[1], len, " %spRequestedQueues (%p)\n%s", prefix, (void*)pStruct->pRequestedQueues, 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%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]); @@ -354,43 +270,16 @@ char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* p free(extra_indent); 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_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%ssize = %p\n%salignment = %p\n%sgranularity = %p\n%smemProps = %u\n%smemType = %s\n", prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->alignment), prefix, (void*)(pStruct->granularity), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType)); - return str; -} -char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData)); - return str; -} -char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix) +char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix) { char* str; size_t len; len = sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%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)); + snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage)); return str; } -char* xgl_print_xgl_device_create_info(const XGL_DEVICE_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; @@ -408,17 +297,17 @@ 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); + 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, " %spRequestedQueues (%p)\n%s", prefix, (void*)pStruct->pRequestedQueues, tmpStr); + 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%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)); + 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])); @@ -428,48 +317,16 @@ char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, co free(extra_indent); return str; } -char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* 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; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[5]; - tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr); - tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %ssrcOffset (%p)\n%s", prefix, (void*)&pStruct->srcOffset, tmpStr); - tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[2] = (char*)malloc(len); - snprintf(stp_strs[2], len, " %sdestSubresource (%p)\n%s", prefix, (void*)&pStruct->destSubresource, tmpStr); - tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[3] = (char*)malloc(len); - snprintf(stp_strs[3], len, " %sdestOffset (%p)\n%s", prefix, (void*)&pStruct->destOffset, tmpStr); - tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[4] = (char*)malloc(len); - snprintf(stp_strs[4], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024; + len = sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent)); - for (int32_t stp_index = 4; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } - } - free(extra_indent); + 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_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_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; @@ -477,7 +334,7 @@ char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_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); @@ -487,40 +344,26 @@ char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pSt } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } + 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); } - free(extra_indent); - return str; -} -char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix) -{ - char* str; - size_t len; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[1]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr); - free(tmpStr); + else + stp_strs[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[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; + stp_strs[2] = ""; + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%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%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]); @@ -559,25 +402,25 @@ char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREA free(extra_indent); return str; } -char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix) +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, "%ssrcOffset = %p\n%sdestOffset = %p\n%scopySize = %p\n", prefix, (void*)(pStruct->srcOffset), prefix, (void*)(pStruct->destOffset), prefix, (void*)(pStruct->copySize)); + 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_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix) +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, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); + 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_buffer_view_create_info(const XGL_BUFFER_VIEW_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; @@ -585,7 +428,7 @@ char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* 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[3]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -595,14 +438,26 @@ 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); - 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; + 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%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--) { + 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]); @@ -611,7 +466,7 @@ char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* p free(extra_indent); return str; } -char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -631,7 +486,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%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])); @@ -641,6 +496,42 @@ char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INF 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* str; @@ -679,46 +570,16 @@ char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CR free(extra_indent); return str; } -char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix) -{ - char* str; - size_t len; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[1]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr); - free(tmpStr); - } - else - stp_strs[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->blendConst)); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } - } - free(extra_indent); - return str; -} -char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix) +char* xgl_print_xgl_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, "%susage = %u\n", prefix, (pStruct->usage)); + 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_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -726,19 +587,24 @@ char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* p char* extra_indent = (char*)malloc(strlen(prefix) + 3); strcpy(extra_indent, " "); strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[1]; - if (pStruct->pImageView) { - tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent); - len = 256+strlen(tmpStr)+strlen(prefix); + char* stp_strs[2]; + if (pStruct->pNext) { + tmpStr = dynamic_display((void*)pStruct->pNext, prefix); + len = 256+strlen(tmpStr); stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spImageView (%p)\n%s", prefix, (void*)pStruct->pImageView, 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_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, "%spSampler = %p\n%spImageView = %p\n", prefix, (void*)(pStruct->pSampler), prefix, (void*)(pStruct->pImageView)); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { + snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource)); + for (int32_t stp_index = 1; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -747,7 +613,25 @@ char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_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_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix) +{ + char* str; + size_t len; + len = sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask)); + return str; +} +char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix) +{ + char* str; + size_t len; + len = sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate)); + return str; +} +char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -755,7 +639,7 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L 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); @@ -765,10 +649,14 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; + tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%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--) { + snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader)); + for (int32_t stp_index = 1; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -777,7 +665,7 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L 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_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -797,7 +685,7 @@ char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* 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%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%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])); @@ -807,7 +695,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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -815,7 +703,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[3]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -825,18 +713,26 @@ 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); + 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, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, tmpStr); + snprintf(stp_strs[1], len, " %spColorAttachments (%p)\n%s", prefix, (void*)pStruct->pColorAttachments, tmpStr); } else stp_strs[1] = ""; - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; + 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%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%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])); free(stp_strs[stp_index]); @@ -845,7 +741,16 @@ char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CR free(extra_indent); return str; } -char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_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_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -853,7 +758,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); @@ -863,10 +768,14 @@ 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; + tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %scs (%p)\n%s", prefix, (void*)&pStruct->cs, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%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%scs = %p\n%sflags = %u\n%slastSetLayout = %p\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout), prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ)); + for (int32_t stp_index = 1; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -875,7 +784,16 @@ char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, cons free(extra_indent); return str; } -char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_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_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -895,7 +813,7 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* 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%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem)); + 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])); @@ -905,7 +823,16 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const free(extra_indent); return str; } -char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix) +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_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -925,7 +852,7 @@ char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_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%sflags = %u\n%slastSetLayout = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout)); + 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])); @@ -935,7 +862,16 @@ char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CR free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix) +char* 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* str; size_t len; @@ -943,7 +879,7 @@ char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_ 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); @@ -953,14 +889,10 @@ 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); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; + len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader)); - for (int32_t stp_index = 1; stp_index >= 0; stp_index--) { + 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]); @@ -999,7 +931,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_barrier(const XGL_PIPELINE_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; @@ -1019,7 +951,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%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])); @@ -1029,7 +961,7 @@ char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const free(extra_indent); return str; } -char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* 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; @@ -1037,7 +969,7 @@ char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* 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); @@ -1047,10 +979,14 @@ char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char } 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%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--) { + 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]); @@ -1059,7 +995,7 @@ char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix) { char* str; size_t len; @@ -1067,7 +1003,7 @@ char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_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[2]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -1077,10 +1013,18 @@ char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CR } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; + if (pStruct->pImageViews) { + tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent); + len = 256+strlen(tmpStr)+strlen(prefix); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %spImageViews (%p)\n%s", prefix, (void*)pStruct->pImageViews, tmpStr); + } + else + stp_strs[1] = ""; + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%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--) { + 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]); @@ -1089,16 +1033,7 @@ char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CR free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask)); - return str; -} -char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1118,7 +1053,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%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])); @@ -1128,7 +1063,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_application_info(const XGL_APPLICATION_INFO* 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; @@ -1136,7 +1071,7 @@ char* xgl_print_xgl_application_info(const XGL_APPLICATION_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[3]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -1146,10 +1081,18 @@ char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + 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); + 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%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion)); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { + 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]); @@ -1158,7 +1101,7 @@ char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const 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_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1178,7 +1121,7 @@ char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_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%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)); + snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n%slastSetLayout = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -1188,7 +1131,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_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix) { char* str; size_t len; @@ -1197,22 +1140,17 @@ char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT strcpy(extra_indent, " "); strncat(extra_indent, prefix, strlen(prefix)); char* stp_strs[2]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr); - free(tmpStr); - } - else - stp_strs[0] = ""; - tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent); + tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr); + tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent); len = 256+strlen(tmpStr); stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr); + snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr); len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource)); + snprintf(str, len, "%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])); @@ -1222,7 +1160,7 @@ char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT free(extra_indent); return str; } -char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1230,23 +1168,20 @@ 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); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr); - tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr); - tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[2] = (char*)malloc(len); - snprintf(stp_strs[2], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; + char* stp_strs[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, "%ssubresource = %p\n%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->subresource), prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent)); - for (int32_t stp_index = 2; stp_index >= 0; stp_index--) { + snprintf(str, len, "%ssType = %s\n%spNext = %p\n%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]); @@ -1255,25 +1190,16 @@ 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_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_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* 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, "%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, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount)); return str; } -char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1281,7 +1207,7 @@ char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pSt 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); @@ -1291,18 +1217,10 @@ 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); - 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%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--) { + 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]); @@ -1311,7 +1229,7 @@ char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pSt 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_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix) { char* str; size_t len; @@ -1331,7 +1249,7 @@ char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* 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%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%sdescriptorType = %s\n%sdescriptorSet = %p\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->descriptorIndex), prefix, (pStruct->count)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -1382,7 +1300,57 @@ char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix) +{ + char* str; + size_t len; + char* tmpStr; + char* extra_indent = (char*)malloc(strlen(prefix) + 3); + strcpy(extra_indent, " "); + strncat(extra_indent, prefix, strlen(prefix)); + char* stp_strs[5]; + tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr); + tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %ssrcOffset (%p)\n%s", prefix, (void*)&pStruct->srcOffset, tmpStr); + tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[2] = (char*)malloc(len); + snprintf(stp_strs[2], len, " %sdestSubresource (%p)\n%s", prefix, (void*)&pStruct->destSubresource, tmpStr); + tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[3] = (char*)malloc(len); + snprintf(stp_strs[3], len, " %sdestOffset (%p)\n%s", prefix, (void*)&pStruct->destOffset, tmpStr); + tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[4] = (char*)malloc(len); + snprintf(stp_strs[4], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent)); + for (int32_t stp_index = 4; stp_index >= 0; stp_index--) { + if (0 < strlen(stp_strs[stp_index])) { + strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); + free(stp_strs[stp_index]); + } + } + free(extra_indent); + return str; +} +char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix) +{ + char* str; + size_t len; + len = sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); + return str; +} +char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1402,7 +1370,7 @@ 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%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -1446,16 +1414,7 @@ char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct free(extra_indent); return str; } -char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE"); - return str; -} -char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1463,7 +1422,7 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* 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); @@ -1473,10 +1432,18 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* } 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%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--) { + 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]); @@ -1485,7 +1452,7 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* free(extra_indent); return str; } -char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix) { char* str; size_t len; @@ -1493,7 +1460,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); @@ -1503,14 +1470,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%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]); @@ -1519,25 +1482,46 @@ char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREA free(extra_indent); return str; } -char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* 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, "%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)); + 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_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* 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, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage)); + 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_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_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; @@ -1545,7 +1529,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[2]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -1555,26 +1539,48 @@ 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); + 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, " %spViewports (%p)\n%s", prefix, (void*)pStruct->pViewports, tmpStr); + snprintf(stp_strs[1], len, " %spSamplerImageViews (%p)\n%s", prefix, (void*)pStruct->pSamplerImageViews, 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); + 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%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); + return str; +} +char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix) +{ + char* str; + size_t len; + char* tmpStr; + char* extra_indent = (char*)malloc(strlen(prefix) + 3); + strcpy(extra_indent, " "); + strncat(extra_indent, prefix, strlen(prefix)); + char* stp_strs[1]; + if (pStruct->pNext) { + tmpStr = dynamic_display((void*)pStruct->pNext, prefix); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr); + free(tmpStr); } else - stp_strs[2] = ""; - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + 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%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%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem)); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -1583,16 +1589,25 @@ char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREA free(extra_indent); return str; } -char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* 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, "%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)); + 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_render_pass_create_info(const XGL_RENDER_PASS_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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1600,7 +1615,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); @@ -1610,22 +1625,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->pTypeCount) { + tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, 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, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, 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%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]); @@ -1643,7 +1654,7 @@ char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix) snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth)); return str; } -char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1651,7 +1662,7 @@ char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREA 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); @@ -1661,10 +1672,14 @@ char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREA } 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%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--) { + 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]); @@ -1673,7 +1688,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_buffer_create_info(const XGL_BUFFER_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; @@ -1693,7 +1708,7 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_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%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)); + 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])); @@ -1703,7 +1718,7 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, co 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* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1723,7 +1738,7 @@ char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS stp_strs[0] = ""; len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderPass = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->renderPass)); + 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])); @@ -1733,36 +1748,25 @@ char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS free(extra_indent); return str; } -char* xgl_print_xgl_rect(const XGL_RECT* 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; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[2]; - tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr); - tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; + len = 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); + 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_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix) +char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix) +{ + char* str; + size_t len; + len = sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%ssize = %p\n%salignment = %p\n%sgranularity = %p\n%smemProps = %u\n%smemType = %s\n", prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->alignment), prefix, (void*)(pStruct->granularity), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType)); + return str; +} +char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1782,7 +1786,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%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])); @@ -1792,7 +1796,7 @@ char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStru 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_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix) { char* str; size_t len; @@ -1800,7 +1804,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); @@ -1810,18 +1814,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%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]); @@ -1830,16 +1826,25 @@ char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CR 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_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, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count)); + 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_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* 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; @@ -1847,28 +1852,15 @@ 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]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr); - free(tmpStr); - } - else - stp_strs[0] = ""; - if (pStruct->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; + 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, "%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--) { + snprintf(str, len, "%scolor = %p\n%suseRawValue = %s\n", prefix, (void*)&(pStruct->color), prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE"); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -1877,7 +1869,7 @@ char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* p 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_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1897,7 +1889,7 @@ char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_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%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)); + 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])); @@ -1907,7 +1899,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_event_create_info(const XGL_EVENT_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; @@ -1915,7 +1907,7 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_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); @@ -1925,10 +1917,14 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, cons } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + 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%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%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]); @@ -1937,16 +1933,7 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, cons free(extra_indent); return str; } -char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y)); - return str; -} -char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* 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; @@ -1954,7 +1941,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); @@ -1964,18 +1951,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%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType)); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -1984,16 +1963,7 @@ char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char 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_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* 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; @@ -2013,7 +1983,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%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])); @@ -2023,7 +1993,7 @@ char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* p free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix) { char* str; size_t len; @@ -2032,6 +2002,39 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_ strcpy(extra_indent, " "); strncat(extra_indent, prefix, strlen(prefix)); char* stp_strs[3]; + tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %simageSubresource (%p)\n%s", prefix, (void*)&pStruct->imageSubresource, tmpStr); + tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %simageOffset (%p)\n%s", prefix, (void*)&pStruct->imageOffset, tmpStr); + tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[2] = (char*)malloc(len); + snprintf(stp_strs[2], len, " %simageExtent (%p)\n%s", prefix, (void*)&pStruct->imageExtent, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%sbufferOffset = %p\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (void*)(pStruct->bufferOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent)); + for (int32_t stp_index = 2; stp_index >= 0; stp_index--) { + if (0 < strlen(stp_strs[stp_index])) { + strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); + free(stp_strs[stp_index]); + } + } + free(extra_indent); + return str; +} +char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix) +{ + char* str; + 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); @@ -2041,26 +2044,10 @@ 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; + len = strlen(stp_strs[0]) + 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%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]); @@ -2069,16 +2056,16 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_ free(extra_indent); return str; } -char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_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, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags)); + 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_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2098,26 +2085,17 @@ 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%sview = %p\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); } - } - free(extra_indent); - return str; -} -char* xgl_print_xgl_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)); + } + free(extra_indent); return str; } -char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2137,7 +2115,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%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])); @@ -2147,7 +2125,16 @@ char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, cons free(extra_indent); return str; } -char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_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* str; size_t len; @@ -2155,24 +2142,23 @@ char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_ char* extra_indent = (char*)malloc(strlen(prefix) + 3); strcpy(extra_indent, " "); strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[2]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr); - free(tmpStr); - } - else - stp_strs[0] = ""; - tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent); + char* stp_strs[3]; + tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr); + tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent); len = 256+strlen(tmpStr); stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; + snprintf(stp_strs[1], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr); + tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[2] = (char*)malloc(len); + snprintf(stp_strs[2], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%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--) { + 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]); @@ -2181,34 +2167,54 @@ char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_ free(extra_indent); return str; } -char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix) +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, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); + 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_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* 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->pLinkConstBufferInfo) { + tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent); + len = 256+strlen(tmpStr)+strlen(prefix); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (%p)\n%s", prefix, (void*)pStruct->pLinkConstBufferInfo, tmpStr); + } + else + stp_strs[0] = ""; + len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples)); + snprintf(str, len, "%sstage = %s\n%sshader = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo)); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { + if (0 < strlen(stp_strs[stp_index])) { + strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); + free(stp_strs[stp_index]); + } + } + free(extra_indent); return str; } -char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix) +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, "%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, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z)); return str; } -char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* 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; @@ -2216,7 +2222,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); @@ -2226,18 +2232,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%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]); @@ -2246,34 +2244,54 @@ char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* free(extra_indent); return str; } -char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix) +char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix) { char* str; size_t len; len = sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z)); + 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_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix) +char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix) { char* str; size_t len; - 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->pImageView) { + tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent); + len = 256+strlen(tmpStr)+strlen(prefix); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %spImageView (%p)\n%s", prefix, (void*)pStruct->pImageView, tmpStr); + } + else + stp_strs[0] = ""; + len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth)); + snprintf(str, len, "%spSampler = %p\n%spImageView = %p\n", prefix, (void*)(pStruct->pSampler), prefix, (void*)(pStruct->pImageView)); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { + if (0 < strlen(stp_strs[stp_index])) { + strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); + free(stp_strs[stp_index]); + } + } + free(extra_indent); return str; } -char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* 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, "%sfloatColor = %p\n%srawColor = %p\n", prefix, (void*)(pStruct->floatColor), prefix, (void*)(pStruct->rawColor)); + 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_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_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; @@ -2293,7 +2311,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%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])); @@ -2303,25 +2321,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_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_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc)); - return str; -} -char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2330,17 +2330,18 @@ char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const ch 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); + 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; 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)); + 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])); @@ -2350,7 +2351,7 @@ char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const ch free(extra_indent); return str; } -char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2370,7 +2371,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%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])); @@ -2380,34 +2381,7 @@ char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE free(extra_indent); 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_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes)); - return str; -} -char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate)); - return str; -} -char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix) +char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2415,7 +2389,7 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* 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); @@ -2425,10 +2399,22 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const ch } 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, "%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--) { + 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]); @@ -2437,7 +2423,7 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const ch 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_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2445,7 +2431,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); @@ -2455,14 +2441,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%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]); @@ -2471,7 +2453,16 @@ char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, cons free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix) +char* 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* str; size_t len; @@ -2491,7 +2482,7 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT stp_strs[0] = ""; len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor)); + 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])); @@ -2501,6 +2492,15 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT free(extra_indent); 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* dynamic_display(const void* pStruct, const char* prefix) { // Cast to APP_INFO ptr initially just to pull sType off struct diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h index 435ef71..b792ea2 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h @@ -115,49 +115,7 @@ char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix); #define snprintf _snprintf #endif // _WIN32 -char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures)); - return str; -} -char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix) -{ - char* str; - size_t len; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[3]; - tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %simageSubresource (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %simageOffset (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[2] = (char*)malloc(len); - snprintf(stp_strs[2], len, " %simageExtent (addr)\n%s", prefix, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sbufferOffset = addr\n%simageSubresource = addr\n%simageOffset = addr\n%simageExtent = addr\n", prefix, prefix, prefix, prefix); - for (int32_t stp_index = 2; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } - } - free(extra_indent); - return str; -} -char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -177,7 +135,7 @@ char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* 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%soriginalMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix); + snprintf(str, len, "%ssType = %s\n%spNext = addr\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -187,25 +145,7 @@ char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStru 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_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE"); - return str; -} -char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -225,7 +165,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%spAppName = addr\n%sappVersion = %u\n%spEngineName = addr\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->appVersion), prefix, prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -235,16 +175,16 @@ char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, free(extra_indent); return str; } -char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* 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, "%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, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix); return str; } -char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix) +char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix) { char* str; size_t len; @@ -264,7 +204,7 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* 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%sdescriptorType = %s\n%sdescriptorSet = addr\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, prefix, (pStruct->descriptorIndex), prefix, (pStruct->count)); + snprintf(str, len, "%ssType = %s\n%spNext = addr\n%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])); @@ -274,41 +214,25 @@ char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char free(extra_indent); return str; } -char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* 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; - 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; + len = sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%scolor = addr\n%suseRawValue = %s\n", prefix, prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE"); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } - } - free(extra_indent); + 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_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix) +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, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height)); + snprintf(str, len, "%soriginalImage = addr\n", prefix); return str; } -char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_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; @@ -316,7 +240,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); @@ -326,26 +250,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->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, " %spColorAttachments (addr)\n%s", prefix, tmpStr); + snprintf(stp_strs[1], len, " %spRequestedQueues (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%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]); @@ -354,43 +270,16 @@ char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* p free(extra_indent); 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_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%ssize = addr\n%salignment = addr\n%sgranularity = addr\n%smemProps = %u\n%smemType = %s\n", prefix, prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType)); - return str; -} -char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix); - return str; -} -char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix) +char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix) { char* str; size_t len; len = sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%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)); + snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage)); return str; } -char* xgl_print_xgl_device_create_info(const XGL_DEVICE_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; @@ -408,17 +297,17 @@ 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); + 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, " %spRequestedQueues (addr)\n%s", prefix, tmpStr); + 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%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)); + 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])); @@ -428,48 +317,16 @@ char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, co free(extra_indent); return str; } -char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* 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; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[5]; - tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %ssrcSubresource (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %ssrcOffset (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[2] = (char*)malloc(len); - snprintf(stp_strs[2], len, " %sdestSubresource (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[3] = (char*)malloc(len); - snprintf(stp_strs[3], len, " %sdestOffset (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[4] = (char*)malloc(len); - snprintf(stp_strs[4], len, " %sextent (addr)\n%s", prefix, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024; + len = sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssrcSubresource = addr\n%ssrcOffset = addr\n%sdestSubresource = addr\n%sdestOffset = addr\n%sextent = addr\n", prefix, prefix, prefix, prefix, prefix); - for (int32_t stp_index = 4; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } - } - free(extra_indent); + 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_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_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; @@ -477,7 +334,7 @@ char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_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); @@ -487,40 +344,26 @@ char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pSt } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } + 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); } - free(extra_indent); - return str; -} -char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix) -{ - char* str; - size_t len; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[1]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr); - free(tmpStr); + else + stp_strs[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[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; + stp_strs[2] = ""; + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%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%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]); @@ -559,25 +402,25 @@ char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREA free(extra_indent); return str; } -char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix) +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, "%ssrcOffset = addr\n%sdestOffset = addr\n%scopySize = addr\n", prefix, prefix, prefix); + 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_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix) +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, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); + 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_buffer_view_create_info(const XGL_BUFFER_VIEW_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; @@ -585,7 +428,7 @@ char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* 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[3]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -595,14 +438,26 @@ 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); - 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; + 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%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--) { + 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]); @@ -611,7 +466,7 @@ char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* p free(extra_indent); return str; } -char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -631,7 +486,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%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])); @@ -641,6 +496,42 @@ char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INF 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* str; @@ -679,46 +570,16 @@ char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CR free(extra_indent); return str; } -char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix) -{ - char* str; - size_t len; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[1]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr); - free(tmpStr); - } - else - stp_strs[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sblendConst = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { - if (0 < strlen(stp_strs[stp_index])) { - strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); - free(stp_strs[stp_index]); - } - } - free(extra_indent); - return str; -} -char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix) +char* xgl_print_xgl_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, "%susage = %u\n", prefix, (pStruct->usage)); + 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_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -726,19 +587,24 @@ char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* p char* extra_indent = (char*)malloc(strlen(prefix) + 3); strcpy(extra_indent, " "); strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[1]; - if (pStruct->pImageView) { - tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent); - len = 256+strlen(tmpStr)+strlen(prefix); + char* stp_strs[2]; + if (pStruct->pNext) { + tmpStr = dynamic_display((void*)pStruct->pNext, prefix); + len = 256+strlen(tmpStr); stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spImageView (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_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, "%spSampler = addr\n%spImageView = addr\n", prefix, prefix); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { + snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix); + for (int32_t stp_index = 1; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -747,7 +613,25 @@ char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_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_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix) +{ + char* str; + size_t len; + len = sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask)); + return str; +} +char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix) +{ + char* str; + size_t len; + len = sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate)); + return str; +} +char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -755,7 +639,7 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L 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); @@ -765,10 +649,14 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; + tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %sshader (addr)\n%s", prefix, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%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--) { + snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix); + for (int32_t stp_index = 1; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -777,7 +665,7 @@ char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_L 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_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -797,7 +685,7 @@ char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* 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%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%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])); @@ -807,7 +695,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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -815,7 +703,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[3]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -825,18 +713,26 @@ 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); + 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, " %spTypeCount (addr)\n%s", prefix, tmpStr); + snprintf(stp_strs[1], len, " %spColorAttachments (addr)\n%s", prefix, tmpStr); } else stp_strs[1] = ""; - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; + 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%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%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])); free(stp_strs[stp_index]); @@ -845,7 +741,16 @@ char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CR free(extra_indent); return str; } -char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_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_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -853,7 +758,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); @@ -863,10 +768,14 @@ 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; + tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %scs (addr)\n%s", prefix, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%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%scs = addr\n%sflags = %u\n%slastSetLayout = addr\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->flags), prefix, prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ)); + for (int32_t stp_index = 1; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -875,7 +784,16 @@ char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, cons free(extra_indent); return str; } -char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_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_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -895,7 +813,7 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* 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%ssharedMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix); + 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])); @@ -905,7 +823,16 @@ char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const free(extra_indent); return str; } -char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix) +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_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -925,7 +852,7 @@ char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_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%sflags = %u\n%slastSetLayout = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags), prefix); + snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->initialCount), prefix, (pStruct->flags)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -935,7 +862,16 @@ char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CR free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix) +char* 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* str; size_t len; @@ -943,7 +879,7 @@ char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_ 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); @@ -953,14 +889,10 @@ 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); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %sshader (addr)\n%s", prefix, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; + len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix); - for (int32_t stp_index = 1; stp_index >= 0; stp_index--) { + 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]); @@ -999,7 +931,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_barrier(const XGL_PIPELINE_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; @@ -1019,7 +951,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%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])); @@ -1029,7 +961,7 @@ char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const free(extra_indent); return str; } -char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* 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; @@ -1037,7 +969,7 @@ char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* 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); @@ -1047,10 +979,14 @@ char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char } 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%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--) { + 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]); @@ -1059,7 +995,7 @@ char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix) { char* str; size_t len; @@ -1067,7 +1003,7 @@ char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_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[2]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -1077,10 +1013,18 @@ char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CR } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + sizeof(char)*1024; + if (pStruct->pImageViews) { + tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent); + len = 256+strlen(tmpStr)+strlen(prefix); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %spImageViews (addr)\n%s", prefix, tmpStr); + } + else + stp_strs[1] = ""; + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%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--) { + 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]); @@ -1089,16 +1033,7 @@ char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CR free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask)); - return str; -} -char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1118,7 +1053,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%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])); @@ -1128,7 +1063,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_application_info(const XGL_APPLICATION_INFO* 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; @@ -1136,7 +1071,7 @@ char* xgl_print_xgl_application_info(const XGL_APPLICATION_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[3]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -1146,10 +1081,18 @@ char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + 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); + 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%spAppName = addr\n%sappVersion = %u\n%spEngineName = addr\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->appVersion), prefix, prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion)); - for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { + 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]); @@ -1158,7 +1101,7 @@ char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const 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_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1178,7 +1121,7 @@ char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_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%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)); + snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n%slastSetLayout = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags), prefix); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -1188,7 +1131,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_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix) { char* str; size_t len; @@ -1197,22 +1140,17 @@ char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT strcpy(extra_indent, " "); strncat(extra_indent, prefix, strlen(prefix)); char* stp_strs[2]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr); - free(tmpStr); - } - else - stp_strs[0] = ""; - tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent); + tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %soffset (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent); len = 256+strlen(tmpStr); stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr); + snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr); len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix); + snprintf(str, len, "%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])); @@ -1222,7 +1160,7 @@ char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT free(extra_indent); return str; } -char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1230,23 +1168,20 @@ 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); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %ssubresource (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %soffset (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[2] = (char*)malloc(len); - snprintf(stp_strs[2], len, " %sextent (addr)\n%s", prefix, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; + char* stp_strs[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, "%ssubresource = addr\n%soffset = addr\n%sextent = addr\n", prefix, prefix, prefix); - for (int32_t stp_index = 2; stp_index >= 0; stp_index--) { + snprintf(str, len, "%ssType = %s\n%spNext = addr\n%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]); @@ -1255,25 +1190,16 @@ 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_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_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* 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, "%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, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount)); return str; } -char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1281,7 +1207,7 @@ char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pSt 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); @@ -1291,18 +1217,10 @@ 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); - 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%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--) { + 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]); @@ -1311,7 +1229,7 @@ char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pSt 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_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix) { char* str; size_t len; @@ -1331,7 +1249,7 @@ char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* 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%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags)); + snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sdescriptorSet = addr\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, prefix, (pStruct->descriptorIndex), prefix, (pStruct->count)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -1382,7 +1300,57 @@ char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix) +{ + char* str; + size_t len; + char* tmpStr; + char* extra_indent = (char*)malloc(strlen(prefix) + 3); + strcpy(extra_indent, " "); + strncat(extra_indent, prefix, strlen(prefix)); + char* stp_strs[5]; + tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %ssrcSubresource (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %ssrcOffset (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[2] = (char*)malloc(len); + snprintf(stp_strs[2], len, " %sdestSubresource (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[3] = (char*)malloc(len); + snprintf(stp_strs[3], len, " %sdestOffset (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[4] = (char*)malloc(len); + snprintf(stp_strs[4], len, " %sextent (addr)\n%s", prefix, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%ssrcSubresource = addr\n%ssrcOffset = addr\n%sdestSubresource = addr\n%sdestOffset = addr\n%sextent = addr\n", prefix, prefix, prefix, prefix, prefix); + for (int32_t stp_index = 4; stp_index >= 0; stp_index--) { + if (0 < strlen(stp_strs[stp_index])) { + strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); + free(stp_strs[stp_index]); + } + } + free(extra_indent); + return str; +} +char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix) +{ + char* str; + size_t len; + len = sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); + return str; +} +char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1402,7 +1370,7 @@ 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%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); @@ -1446,16 +1414,7 @@ char* xgl_print_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct free(extra_indent); return str; } -char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE"); - return str; -} -char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1463,7 +1422,7 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* 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); @@ -1473,10 +1432,18 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* } 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%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--) { + 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]); @@ -1485,7 +1452,7 @@ char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* free(extra_indent); return str; } -char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix) { char* str; size_t len; @@ -1493,7 +1460,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); @@ -1503,14 +1470,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%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]); @@ -1519,25 +1482,46 @@ char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREA free(extra_indent); return str; } -char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* 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, "%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)); + 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_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* 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, "%soriginalImage = addr\n", prefix); + 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_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_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; @@ -1545,7 +1529,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[2]; if (pStruct->pNext) { tmpStr = dynamic_display((void*)pStruct->pNext, prefix); len = 256+strlen(tmpStr); @@ -1555,26 +1539,48 @@ 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); + 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, " %spViewports (addr)\n%s", prefix, tmpStr); + snprintf(stp_strs[1], len, " %spSamplerImageViews (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); + 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%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); + return str; +} +char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix) +{ + char* str; + size_t len; + char* tmpStr; + char* extra_indent = (char*)malloc(strlen(prefix) + 3); + strcpy(extra_indent, " "); + strncat(extra_indent, prefix, strlen(prefix)); + char* stp_strs[1]; + if (pStruct->pNext) { + tmpStr = dynamic_display((void*)pStruct->pNext, prefix); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr); + free(tmpStr); } else - stp_strs[2] = ""; - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + 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%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%soriginalMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -1583,16 +1589,25 @@ char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREA free(extra_indent); return str; } -char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* 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, "%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)); + 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_render_pass_create_info(const XGL_RENDER_PASS_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_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1600,7 +1615,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); @@ -1610,22 +1625,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->pTypeCount) { + tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, 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, " %spTypeCount (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%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]); @@ -1643,7 +1654,7 @@ char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix) snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth)); return str; } -char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1651,7 +1662,7 @@ char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREA 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); @@ -1661,10 +1672,14 @@ char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREA } 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%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--) { + 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]); @@ -1673,7 +1688,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_buffer_create_info(const XGL_BUFFER_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; @@ -1693,7 +1708,7 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_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%ssize = addr\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->usage), 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])); @@ -1703,7 +1718,7 @@ char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, co 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* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1723,7 +1738,7 @@ char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS stp_strs[0] = ""; len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderPass = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix); + 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])); @@ -1733,36 +1748,25 @@ char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS free(extra_indent); return str; } -char* xgl_print_xgl_rect(const XGL_RECT* 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; - char* tmpStr; - char* extra_indent = (char*)malloc(strlen(prefix) + 3); - strcpy(extra_indent, " "); - strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[2]; - tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %soffset (addr)\n%s", prefix, tmpStr); - tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent); - len = 256+strlen(tmpStr); - stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; + len = 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); + snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); return str; } -char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix) +char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix) +{ + char* str; + size_t len; + len = sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%ssize = addr\n%salignment = addr\n%sgranularity = addr\n%smemProps = %u\n%smemType = %s\n", prefix, prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType)); + return str; +} +char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1782,7 +1786,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%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])); @@ -1792,7 +1796,7 @@ char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStru 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_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix) { char* str; size_t len; @@ -1800,7 +1804,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); @@ -1810,18 +1814,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%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]); @@ -1830,16 +1826,25 @@ char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CR 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_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, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count)); + 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_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* 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; @@ -1847,28 +1852,15 @@ 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]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr); - free(tmpStr); - } - else - stp_strs[0] = ""; - if (pStruct->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; + 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, "%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--) { + snprintf(str, len, "%scolor = addr\n%suseRawValue = %s\n", prefix, prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE"); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -1877,7 +1869,7 @@ char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* p 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_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -1897,7 +1889,7 @@ char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_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%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots)); + 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])); @@ -1907,7 +1899,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_event_create_info(const XGL_EVENT_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; @@ -1915,7 +1907,7 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_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); @@ -1925,10 +1917,14 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, cons } else stp_strs[0] = ""; - len = strlen(stp_strs[0]) + 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%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%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]); @@ -1937,16 +1933,7 @@ char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, cons free(extra_indent); return str; } -char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y)); - return str; -} -char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* 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; @@ -1954,7 +1941,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); @@ -1964,18 +1951,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%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType)); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); @@ -1984,16 +1963,7 @@ char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char 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_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* 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; @@ -2013,7 +1983,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%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])); @@ -2023,7 +1993,7 @@ char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* p free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix) { char* str; size_t len; @@ -2032,6 +2002,39 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_ strcpy(extra_indent, " "); strncat(extra_indent, prefix, strlen(prefix)); char* stp_strs[3]; + tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %simageSubresource (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[1] = (char*)malloc(len); + snprintf(stp_strs[1], len, " %simageOffset (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[2] = (char*)malloc(len); + snprintf(stp_strs[2], len, " %simageExtent (addr)\n%s", prefix, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; + str = (char*)malloc(len); + snprintf(str, len, "%sbufferOffset = addr\n%simageSubresource = addr\n%simageOffset = addr\n%simageExtent = addr\n", prefix, prefix, prefix, prefix); + for (int32_t stp_index = 2; stp_index >= 0; stp_index--) { + if (0 < strlen(stp_strs[stp_index])) { + strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); + free(stp_strs[stp_index]); + } + } + free(extra_indent); + return str; +} +char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix) +{ + char* str; + 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); @@ -2041,26 +2044,10 @@ 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; + len = strlen(stp_strs[0]) + 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%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]); @@ -2069,16 +2056,16 @@ char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_ free(extra_indent); return str; } -char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_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, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags)); + 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_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2098,26 +2085,17 @@ 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%sview = addr\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { if (0 < strlen(stp_strs[stp_index])) { strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); free(stp_strs[stp_index]); } - } - free(extra_indent); - return str; -} -char* xgl_print_xgl_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)); + } + free(extra_indent); return str; } -char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2137,7 +2115,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%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])); @@ -2147,7 +2125,16 @@ char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, cons free(extra_indent); return str; } -char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_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* str; size_t len; @@ -2155,24 +2142,23 @@ char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_ char* extra_indent = (char*)malloc(strlen(prefix) + 3); strcpy(extra_indent, " "); strncat(extra_indent, prefix, strlen(prefix)); - char* stp_strs[2]; - if (pStruct->pNext) { - tmpStr = dynamic_display((void*)pStruct->pNext, prefix); - len = 256+strlen(tmpStr); - stp_strs[0] = (char*)malloc(len); - snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr); - free(tmpStr); - } - else - stp_strs[0] = ""; - tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent); + char* stp_strs[3]; + tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %ssubresource (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent); len = 256+strlen(tmpStr); stp_strs[1] = (char*)malloc(len); - snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr); - len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024; + snprintf(stp_strs[1], len, " %soffset (addr)\n%s", prefix, tmpStr); + tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent); + len = 256+strlen(tmpStr); + stp_strs[2] = (char*)malloc(len); + snprintf(stp_strs[2], len, " %sextent (addr)\n%s", prefix, tmpStr); + len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%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--) { + 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]); @@ -2181,34 +2167,54 @@ char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_ free(extra_indent); return str; } -char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix) +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, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout)); + 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_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* 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->pLinkConstBufferInfo) { + tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent); + len = 256+strlen(tmpStr)+strlen(prefix); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (addr)\n%s", prefix, tmpStr); + } + else + stp_strs[0] = ""; + len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples)); + snprintf(str, len, "%sstage = %s\n%sshader = addr\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = addr\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, prefix, (pStruct->linkConstBufferCount), prefix); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { + if (0 < strlen(stp_strs[stp_index])) { + strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); + free(stp_strs[stp_index]); + } + } + free(extra_indent); return str; } -char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix) +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, "%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, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z)); return str; } -char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* 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; @@ -2216,7 +2222,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); @@ -2226,18 +2232,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%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]); @@ -2246,34 +2244,54 @@ char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* free(extra_indent); return str; } -char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix) +char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix) { char* str; size_t len; len = sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z)); + 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_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix) +char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix) { char* str; size_t len; - 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->pImageView) { + tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent); + len = 256+strlen(tmpStr)+strlen(prefix); + stp_strs[0] = (char*)malloc(len); + snprintf(stp_strs[0], len, " %spImageView (addr)\n%s", prefix, tmpStr); + } + else + stp_strs[0] = ""; + len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth)); + snprintf(str, len, "%spSampler = addr\n%spImageView = addr\n", prefix, prefix); + for (int32_t stp_index = 0; stp_index >= 0; stp_index--) { + if (0 < strlen(stp_strs[stp_index])) { + strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index])); + free(stp_strs[stp_index]); + } + } + free(extra_indent); return str; } -char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* 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, "%sfloatColor = addr\n%srawColor = addr\n", prefix, prefix); + 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_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_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; @@ -2293,7 +2311,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%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])); @@ -2303,25 +2321,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_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_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc)); - return str; -} -char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix) +char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2330,17 +2330,18 @@ char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const ch 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); + 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; 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); + 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])); @@ -2350,7 +2351,7 @@ char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const ch free(extra_indent); return str; } -char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix) +char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2370,7 +2371,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%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])); @@ -2380,34 +2381,7 @@ char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE free(extra_indent); 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_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes)); - return str; -} -char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix) -{ - char* str; - size_t len; - len = sizeof(char)*1024; - str = (char*)malloc(len); - snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate)); - return str; -} -char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix) +char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2415,7 +2389,7 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* 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); @@ -2425,10 +2399,22 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const ch } 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, "%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--) { + 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]); @@ -2437,7 +2423,7 @@ char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const ch 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_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix) { char* str; size_t len; @@ -2445,7 +2431,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); @@ -2455,14 +2441,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%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]); @@ -2471,7 +2453,16 @@ char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, cons free(extra_indent); return str; } -char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix) +char* 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* str; size_t len; @@ -2491,7 +2482,7 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT stp_strs[0] = ""; len = strlen(stp_strs[0]) + sizeof(char)*1024; str = (char*)malloc(len); - snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor)); + 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])); @@ -2501,6 +2492,15 @@ char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STAT free(extra_indent); 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* dynamic_display(const void* pStruct, const char* prefix) { // Cast to APP_INFO ptr initially just to pull sType off struct diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h index f72db36..e50bd3d 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h @@ -8,279 +8,231 @@ #include "xgl_enum_validate_helper.h" // Function Prototypes -uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct); -uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct); -uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct); -uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct); -uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct); -uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct); -uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct); -uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct); -uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct); -uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct); -uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct); +uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* 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_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* 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_image_resolve(const XGL_IMAGE_RESOLVE* pStruct); -uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct); -uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_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_buffer_copy(const XGL_BUFFER_COPY* pStruct); -uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct); -uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct); +uint32_t xgl_validate_xgl_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_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct); -uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct); -uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct); -uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct); -uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct); -uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct); +uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct); +uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct); uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct); +uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct); +uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct); +uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct); +uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct); uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct); -uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct); -uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct); -uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct); uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct); -uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct); -uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct); -uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct); uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct); +uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct); +uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct); +uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct); +uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct); uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct); -uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct); -uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct); -uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct); -uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct); -uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct); -uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct); -uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct); +uint32_t xgl_validate_xgl_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_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct); -uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct); -uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct); +uint32_t xgl_validate_xgl_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_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* 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_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct); -uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct); -uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct); -uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct); -uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct); -uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct); -uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct); +uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct); +uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct); +uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct); uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct); uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct); +uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct); +uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct); +uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct); +uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct); +uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct); +uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct); +uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct); +uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct); +uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct); +uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct); +uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct); +uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct); +uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct); uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct); -uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct); -uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct); -uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct); -uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct); -uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct); -uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct); -uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct); uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct); -uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct); -uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct); -uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct); -uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct); -uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct); -uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct); +uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct); +uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct); +uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct); +uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct); +uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct); +uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct); +uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct); +uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct); -uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct) -{ - return 1; -} -uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct) +uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* 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)) + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->imageExtent)) + if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology)) return 0; return 1; } -uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct) +uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; return 1; } -uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct) +uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct) { return 1; } -uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* 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_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) - return 0; - if (!validate_XGL_TEX_FILTER(pStruct->magFilter)) - return 0; - if (!validate_XGL_TEX_FILTER(pStruct->minFilter)) - return 0; - if (!validate_XGL_TEX_MIPMAP_MODE(pStruct->mipMode)) - return 0; - if (!validate_XGL_TEX_ADDRESS(pStruct->addressU)) - return 0; - if (!validate_XGL_TEX_ADDRESS(pStruct->addressV)) + if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp)) return 0; - if (!validate_XGL_TEX_ADDRESS(pStruct->addressW)) + if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp)) return 0; - if (!validate_XGL_COMPARE_FUNC(pStruct->compareFunc)) + if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp)) return 0; - if (!validate_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType)) + if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc)) return 0; return 1; } -uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct) +uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct) { return 1; } -uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* 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 (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType)) + if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues)) 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 (!validate_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel)) return 0; return 1; } -uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct) +uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct) { return 1; } -uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments)) + if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType)) return 0; - if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment)) + 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_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct) -{ - return 1; -} -uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct) +uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct) { - if (!validate_XGL_MEMORY_TYPE(pStruct->memType)) + if (!validate_XGL_FORMAT(pStruct->format)) return 0; return 1; } -uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct) -{ - return 1; -} -uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct) +uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct) { - if (!validate_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType)) + 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_device_create_info(const XGL_DEVICE_CREATE_INFO* 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; - if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues)) - return 0; - if (!validate_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel)) - return 0; return 1; } -uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct) +uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct) { - if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource)) - return 0; - if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset)) - return 0; - if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource)) - return 0; - if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset)) - return 0; - if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent)) - return 0; return 1; } -uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct) +uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* 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_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; + if (pStruct->pViewports && !xgl_validate_xgl_viewport((const XGL_VIEWPORT*)pStruct->pViewports)) + return 0; + if (pStruct->pScissors && !xgl_validate_xgl_rect((const XGL_RECT*)pStruct->pScissors)) + return 0; return 1; } -uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_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; return 1; } -uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct) +uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct) { return 1; } -uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct) +uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct) { - if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout)) - return 0; return 1; } -uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) - return 0; - if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType)) - return 0; - if (!validate_XGL_FORMAT(pStruct->format)) - return 0; - if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels)) - return 0; return 1; } -uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct) +uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* 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) @@ -293,131 +245,113 @@ uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_ST return 0; return 1; } -uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct) -{ - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) - return 0; - return 1; -} -uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct) +uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct) { return 1; } -uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct) +uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct) { - if (pStruct->pImageView && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageView)) + 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_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) + if (!validate_XGL_FORMAT(pStruct->format)) return 0; - if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType)) + if (!validate_XGL_BLEND(pStruct->srcBlendColor)) + return 0; + if (!validate_XGL_BLEND(pStruct->destBlendColor)) + return 0; + if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor)) + return 0; + if (!validate_XGL_BLEND(pStruct->srcBlendAlpha)) + return 0; + if (!validate_XGL_BLEND(pStruct->destBlendAlpha)) + return 0; + if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha)) return 0; return 1; } -uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_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_WAIT_EVENT(pStruct->waitEvent)) + if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate)) 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_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct) +uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (!validate_XGL_MEMORY_TYPE(pStruct->memType)) - return 0; - if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority)) - return 0; return 1; } -uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct) +uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; + if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments)) + return 0; + if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment)) + return 0; return 1; } -uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) - return 0; return 1; } -uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct) +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->shader)) + if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs)) 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_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) + if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect)) return 0; return 1; } -uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* 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 (!validate_XGL_WAIT_EVENT(pStruct->waitEvent)) - return 0; return 1; } -uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* 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_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_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; - if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology)) - return 0; return 1; } -uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct) +uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct) { - if (!validate_XGL_FORMAT(pStruct->format)) - return 0; - if (!validate_XGL_BLEND(pStruct->srcBlendColor)) - return 0; - if (!validate_XGL_BLEND(pStruct->destBlendColor)) - return 0; - if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor)) - return 0; - if (!validate_XGL_BLEND(pStruct->srcBlendAlpha)) - return 0; - if (!validate_XGL_BLEND(pStruct->destBlendAlpha)) - return 0; - if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha)) - return 0; return 1; } -uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (!validate_XGL_QUEUE_TYPE(pStruct->queueType)) - return 0; return 1; } -uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct) +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; @@ -439,36 +373,36 @@ uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_ST return 0; 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_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; + if (!validate_XGL_IMAGE_TYPE(pStruct->imageType)) + return 0; if (!validate_XGL_FORMAT(pStruct->format)) return 0; - if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource)) + 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_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct) +uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct) { - if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->subresource)) + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->offset)) + if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType)) return 0; - if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent)) + 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_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct) +uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct) { - if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect)) + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; return 1; } -uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct) -{ - return 1; -} uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) @@ -483,10 +417,42 @@ uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INF 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_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct) +{ + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) + return 0; + return 1; +} +uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct) +{ + if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset)) + return 0; + if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent)) + return 0; + return 1; +} +uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct) +{ + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) + return 0; + return 1; +} +uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct) +{ + return 1; +} +uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct) +{ + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) + return 0; + return 1; +} +uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; + if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType)) + return 0; return 1; } uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct) @@ -503,351 +469,385 @@ uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct) 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_image_resolve(const XGL_IMAGE_RESOLVE* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) - return 0; - if (!validate_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin)) - return 0; - if (!validate_XGL_DEPTH_MODE(pStruct->depthMode)) + if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource)) return 0; - return 1; -} -uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct) -{ - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) + if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset)) return 0; - if (!validate_XGL_IMAGE_LAYOUT(pStruct->oldLayout)) + if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource)) return 0; - if (!validate_XGL_IMAGE_LAYOUT(pStruct->newLayout)) + if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset)) return 0; - if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange)) + if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent)) return 0; return 1; } -uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* 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_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_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_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_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 (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs)) + 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_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct) +uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct) { - if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->r)) + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->g)) + if (!validate_XGL_FORMAT(pStruct->format)) return 0; - if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->b)) + if (!validate_XGL_COMPARE_FUNC(pStruct->depthFunc)) + return 0; + if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->front)) + return 0; + if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->back)) + return 0; + return 1; +} +uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct) +{ + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->a)) + if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent)) 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_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct) { return 1; } -uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_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 (pStruct->pViewports && !xgl_validate_xgl_viewport((const XGL_VIEWPORT*)pStruct->pViewports)) - return 0; - if (pStruct->pScissors && !xgl_validate_xgl_rect((const XGL_RECT*)pStruct->pScissors)) + if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass)) return 0; return 1; } -uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* 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 (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_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct) +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; - 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)) - return 0; return 1; } -uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct) +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_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) - return 0; return 1; } -uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct) +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_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct) +uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* 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_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct) { - if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset)) + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent)) + if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource)) return 0; return 1; } -uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct) +uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; + if (!validate_XGL_QUERY_TYPE(pStruct->queryType)) + return 0; return 1; } -uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct) +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_FORMAT(pStruct->format)) - return 0; - if (!validate_XGL_COMPARE_FUNC(pStruct->depthFunc)) - return 0; - if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->front)) - return 0; - if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->back)) + if (!validate_XGL_QUEUE_TYPE(pStruct->queueType)) return 0; return 1; } -uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct) +uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct) { - if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->type)) + if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout)) return 0; return 1; } -uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct) +uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* 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_MEMORY_TYPE(pStruct->memType)) 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_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; - if (!validate_XGL_QUERY_TYPE(pStruct->queryType)) - return 0; return 1; } -uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; return 1; } -uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct) +uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct) { return 1; } -uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct) +uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) + if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->r)) return 0; - if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType)) + if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->g)) return 0; - if (pStruct->pBufferViews && !xgl_validate_xgl_buffer_view_attach_info((const XGL_BUFFER_VIEW_ATTACH_INFO*)pStruct->pBufferViews)) + 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_memory_ref(const XGL_MEMORY_REF* 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_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_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; 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_buffer_view_create_info(const XGL_BUFFER_VIEW_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)) + if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType)) return 0; - if (pStruct->pVertexAttributeDescriptions && !xgl_validate_xgl_vertex_input_attribute_description((const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*)pStruct->pVertexAttributeDescriptions)) + if (!validate_XGL_FORMAT(pStruct->format)) + return 0; + if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels)) return 0; return 1; } -uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct) +uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct) { + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) + return 0; + if (!validate_XGL_TEX_FILTER(pStruct->magFilter)) + return 0; + if (!validate_XGL_TEX_FILTER(pStruct->minFilter)) + return 0; + if (!validate_XGL_TEX_MIPMAP_MODE(pStruct->mipMode)) + return 0; + if (!validate_XGL_TEX_ADDRESS(pStruct->addressU)) + return 0; + if (!validate_XGL_TEX_ADDRESS(pStruct->addressV)) + return 0; + if (!validate_XGL_TEX_ADDRESS(pStruct->addressW)) + return 0; + if (!validate_XGL_COMPARE_FUNC(pStruct->compareFunc)) + return 0; + if (!validate_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType)) + return 0; return 1; } -uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* 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_offset3d(const XGL_OFFSET3D* 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_layer_create_info(const XGL_LAYER_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_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* 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 (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource)) + if (!validate_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType)) return 0; return 1; } -uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_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_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct) +uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct) { - if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass)) + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; return 1; } -uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct) +uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct) { - if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect)) - return 0; return 1; } -uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* 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 (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType)) + if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->offset)) return 0; - if (pStruct->pImageViews && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageViews)) + if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent)) return 0; return 1; } -uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* 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_extent3d(const XGL_EXTENT3D* 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_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct) +uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct) { return 1; } -uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* 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; - if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass)) - return 0; return 1; } -uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct) +uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct) { return 1; } -uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct) +uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct) { - if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp)) - return 0; - if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp)) - return 0; - if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp)) - return 0; - if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc)) + 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_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct) +uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* 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)) + if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect)) 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_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* 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_COORDINATE_ORIGIN(pStruct->clipOrigin)) + return 0; + if (!validate_XGL_DEPTH_MODE(pStruct->depthMode)) + 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_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct) { - if (!validate_XGL_FORMAT(pStruct->format)) + if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; return 1; } -uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct) +uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct) { - if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate)) + 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)) return 0; return 1; } -uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct) +uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct) { if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) return 0; + if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType)) + return 0; return 1; } -uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct) +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) { 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)) + if (!validate_XGL_MEMORY_TYPE(pStruct->memType)) return 0; - if (!validate_XGL_IMAGE_TILING(pStruct->tiling)) + if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority)) 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_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct) { - if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType)) - return 0; return 1; } \ No newline at end of file diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp index 8cbe8bd..90ba170 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp @@ -400,527 +400,533 @@ void dynamic_display_full_txt(const void* pStruct, uint32_t indent) } -// xgl_format_properties_struct_wrapper class definition -xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// xgl_pipeline_ia_state_create_info_struct_wrapper class definition +xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0') +xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {} +xgl_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_format_properties_struct_wrapper::display_single_txt() +void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr); + printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr); } // Private helper function that displays the members of the wrapped struct -void xgl_format_properties_struct_wrapper::display_struct_members() +void xgl_pipeline_ia_state_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 %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_format_properties_struct_wrapper::display_txt() +void xgl_pipeline_ia_state_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_FORMAT_PROPERTIES 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_format_properties_struct_wrapper::display_full_txt() +void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); + if (m_struct.pNext) { + dynamic_display_full_txt(m_struct.pNext, m_indent); + } } -// xgl_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_application_info_struct_wrapper class definition +xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_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_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {} +xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_buffer_image_copy_struct_wrapper::display_single_txt() +void xgl_application_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_BUFFER_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr); + printf(" %*sXGL_APPLICATION_INFO = %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_application_info_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 %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); + printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); + printf("%*s %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName)); + printf("%*s %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion)); + printf("%*s %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName)); + printf("%*s %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion)); + printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion)); } // Output all struct elements, each on their own line -void xgl_buffer_image_copy_struct_wrapper::display_txt() +void xgl_application_info_struct_wrapper::display_txt() { - printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); } // Output all struct elements, and for any structs pointed to, print complete contents -void xgl_buffer_image_copy_struct_wrapper::display_full_txt() +void xgl_application_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_APPLICATION_INFO 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(); + 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_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_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_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_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {} +xgl_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_peer_memory_open_info_struct_wrapper::display_single_txt() +void xgl_link_const_buffer_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr); + printf(" %*sXGL_LINK_CONST_BUFFER = %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_link_const_buffer_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 %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_peer_memory_open_info_struct_wrapper::display_txt() +void xgl_link_const_buffer_struct_wrapper::display_txt() { - printf("%*sXGL_PEER_MEMORY_OPEN_INFO 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_peer_memory_open_info_struct_wrapper::display_full_txt() +void xgl_link_const_buffer_struct_wrapper::display_full_txt() { - printf("%*sXGL_PEER_MEMORY_OPEN_INFO 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.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); - } } -// 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_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_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* 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_subresource_layout_struct_wrapper::~xgl_subresource_layout_struct_wrapper() {} +xgl_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_subresource_layout_struct_wrapper::display_single_txt() +void xgl_update_samplers_struct_wrapper::display_single_txt() { - printf(" %*sXGL_SUBRESOURCE_LAYOUT = %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_subresource_layout_struct_wrapper::display_struct_members() +void xgl_update_samplers_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)); + 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; idisplay_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_update_samplers_struct_wrapper::display_full_txt() { - printf("%*sXGL_SUBRESOURCE_LAYOUT 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(); + 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_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_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_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_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {} +xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt() +void xgl_stencil_op_state_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %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_physical_gpu_queue_properties_struct_wrapper::display_struct_members() +void xgl_stencil_op_state_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 %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_physical_gpu_queue_properties_struct_wrapper::display_txt() +void xgl_stencil_op_state_struct_wrapper::display_txt() { - printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES 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_physical_gpu_queue_properties_struct_wrapper::display_full_txt() +void xgl_stencil_op_state_struct_wrapper::display_full_txt() { - printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES 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(); } -// 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_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_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_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_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_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_sampler_create_info_struct_wrapper::display_single_txt() +void xgl_peer_image_open_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_SAMPLER_CREATE_INFO = %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_sampler_create_info_struct_wrapper::display_struct_members() +void xgl_peer_image_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 %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 %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage)); } // Output all struct elements, each on their own line -void xgl_sampler_create_info_struct_wrapper::display_txt() +void xgl_peer_image_open_info_struct_wrapper::display_txt() { - printf("%*sXGL_SAMPLER_CREATE_INFO 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_sampler_create_info_struct_wrapper::display_full_txt() +void xgl_peer_image_open_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_SAMPLER_CREATE_INFO 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(); - if (m_struct.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); - } } -// xgl_draw_indexed_indirect_cmd_struct_wrapper class definition -xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_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_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_draw_indexed_indirect_cmd_struct_wrapper::~xgl_draw_indexed_indirect_cmd_struct_wrapper() {} +xgl_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_single_txt() +void xgl_device_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_DRAW_INDEXED_INDIRECT_CMD = %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_draw_indexed_indirect_cmd_struct_wrapper::display_struct_members() +void xgl_device_create_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)); -} - -// Output all struct elements, each on their own line -void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_txt() + 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; idisplay_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_device_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD 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; idisplay_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_buffer_memory_requirements_struct_wrapper::display_full_txt() { - printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_BUFFER_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_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_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_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* 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_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {} +xgl_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_clear_color_struct_wrapper::display_single_txt() +void xgl_update_buffers_struct_wrapper::display_single_txt() { - printf(" %*sXGL_CLEAR_COLOR = %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_clear_color_struct_wrapper::display_struct_members() +void xgl_update_buffers_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 %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; idisplay_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_update_buffers_struct_wrapper::display_full_txt() { - printf("%*sXGL_CLEAR_COLOR 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(); - if (&m_struct.color) { - xgl_clear_color_value_struct_wrapper class0(&m_struct.color); - class0.set_indent(m_indent + 4); - class0.display_full_txt(); + uint32_t i; + for (i = 0; idisplay_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_vertex_input_attribute_description_struct_wrapper::display_full_txt() { - printf("%*sXGL_EXTENT2D 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_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_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_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_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_framebuffer_create_info_struct_wrapper::~xgl_framebuffer_create_info_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_framebuffer_create_info_struct_wrapper::display_single_txt() +void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_FRAMEBUFFER_CREATE_INFO = %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_framebuffer_create_info_struct_wrapper::display_struct_members() +void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount)); + printf("%*s %sbindingCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bindingCount)); uint32_t i; - for (i = 0; idisplay_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_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_FRAMEBUFFER_CREATE_INFO 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(); - 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; idisplay_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_dynamic_rs_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_ALLOC_CALLBACKS 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); + } } -// 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_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_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* 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_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {} +xgl_subresource_layout_struct_wrapper::~xgl_subresource_layout_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_memory_requirements_struct_wrapper::display_single_txt() +void xgl_subresource_layout_struct_wrapper::display_single_txt() { - printf(" %*sXGL_MEMORY_REQUIREMENTS = %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_memory_requirements_struct_wrapper::display_struct_members() +void xgl_subresource_layout_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 %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 %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_memory_requirements_struct_wrapper::display_txt() +void xgl_subresource_layout_struct_wrapper::display_txt() { - printf("%*sXGL_MEMORY_REQUIREMENTS 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_memory_requirements_struct_wrapper::display_full_txt() +void xgl_subresource_layout_struct_wrapper::display_full_txt() { - printf("%*sXGL_MEMORY_REQUIREMENTS 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_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_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_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_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_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_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_link_const_buffer_struct_wrapper::display_single_txt() +void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_single_txt() { - printf(" %*sXGL_LINK_CONST_BUFFER = %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_link_const_buffer_struct_wrapper::display_struct_members() +void xgl_draw_indexed_indirect_cmd_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 %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_link_const_buffer_struct_wrapper::display_txt() +void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_txt() { - printf("%*sXGL_LINK_CONST_BUFFER 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_link_const_buffer_struct_wrapper::display_full_txt() +void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_full_txt() { - printf("%*sXGL_LINK_CONST_BUFFER 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(); } -// 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_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_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_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_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_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_physical_gpu_properties_struct_wrapper::display_single_txt() +void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %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_physical_gpu_properties_struct_wrapper::display_struct_members() +void xgl_dynamic_vp_state_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 %sviewportAndScissorCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.viewportAndScissorCount)); uint32_t i; - for (i = 0; idisplay_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_dynamic_vp_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_PHYSICAL_GPU_PROPERTIES 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; idisplay_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_shader_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_DEVICE_CREATE_INFO 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(); - uint32_t i; - for (i = 0; idisplay_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_memory_ref_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_RESOLVE 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.extent) { - xgl_extent2d_struct_wrapper class0(&m_struct.extent); - class0.set_indent(m_indent + 4); - class0.display_full_txt(); - } - if (&m_struct.destOffset) { - xgl_offset2d_struct_wrapper class1(&m_struct.destOffset); - class1.set_indent(m_indent + 4); - class1.display_full_txt(); - } - if (&m_struct.destSubresource) { - xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource); - class2.set_indent(m_indent + 4); - class2.display_full_txt(); - } - if (&m_struct.srcOffset) { - xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset); - class3.set_indent(m_indent + 4); - class3.display_full_txt(); - } - if (&m_struct.srcSubresource) { - xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource); - class4.set_indent(m_indent + 4); - class4.display_full_txt(); - } } -// xgl_image_view_attach_info_struct_wrapper class definition -xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_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_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_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {} +xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_image_view_attach_info_struct_wrapper::display_single_txt() +void xgl_format_properties_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_VIEW_ATTACH_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_view_attach_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 %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 %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_view_attach_info_struct_wrapper::display_txt() +void xgl_format_properties_struct_wrapper::display_txt() { - printf("%*sXGL_IMAGE_VIEW_ATTACH_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_view_attach_info_struct_wrapper::display_full_txt() +void xgl_format_properties_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_VIEW_ATTACH_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.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_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_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_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_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {} +xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_fence_create_info_struct_wrapper::display_single_txt() +void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt() { - printf(" %*sXGL_FENCE_CREATE_INFO = %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_fence_create_info_struct_wrapper::display_struct_members() +void xgl_pipeline_statistics_data_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 %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_fence_create_info_struct_wrapper::display_txt() +void xgl_pipeline_statistics_data_struct_wrapper::display_txt() { - printf("%*sXGL_FENCE_CREATE_INFO 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_fence_create_info_struct_wrapper::display_full_txt() +void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt() { - printf("%*sXGL_FENCE_CREATE_INFO 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.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_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_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_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_dynamic_rs_state_create_info_struct_wrapper::~xgl_dynamic_rs_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_dynamic_rs_state_create_info_struct_wrapper::display_single_txt() +void xgl_alloc_callbacks_struct_wrapper::display_single_txt() { - printf(" %*sXGL_DYNAMIC_RS_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_dynamic_rs_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 %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 %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_dynamic_rs_state_create_info_struct_wrapper::display_txt() +void xgl_alloc_callbacks_struct_wrapper::display_txt() { - printf("%*sXGL_DYNAMIC_RS_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_dynamic_rs_state_create_info_struct_wrapper::display_full_txt() +void xgl_alloc_callbacks_struct_wrapper::display_full_txt() { - printf("%*sXGL_DYNAMIC_RS_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); - } } -// 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_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_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* 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_buffer_copy_struct_wrapper::~xgl_buffer_copy_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_buffer_copy_struct_wrapper::display_single_txt() +void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_BUFFER_COPY = %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_buffer_copy_struct_wrapper::display_struct_members() +void xgl_pipeline_cb_state_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 %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; idisplay_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_pipeline_cb_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_BUFFER_COPY 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; idisplay_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_draw_indirect_cmd_struct_wrapper::display_full_txt() { - printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO 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_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_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_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_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_buffer_view_create_info_struct_wrapper::~xgl_buffer_view_create_info_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_buffer_view_create_info_struct_wrapper::display_single_txt() +void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_BUFFER_VIEW_CREATE_INFO = %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_buffer_view_create_info_struct_wrapper::display_struct_members() +void xgl_color_attachment_view_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %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 %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 %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 %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_buffer_view_create_info_struct_wrapper::display_txt() +void xgl_color_attachment_view_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_BUFFER_VIEW_CREATE_INFO 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_buffer_view_create_info_struct_wrapper::display_full_txt() +void xgl_color_attachment_view_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_COLOR_ATTACHMENT_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); + if (&m_struct.msaaResolveSubResource) { + xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource); class0.set_indent(m_indent + 4); class0.display_full_txt(); } @@ -1525,441 +1514,435 @@ void xgl_buffer_view_create_info_struct_wrapper::display_full_txt() } -// 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_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_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_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_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_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_queue_semaphore_open_info_struct_wrapper::display_single_txt() +void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt() { - printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %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_queue_semaphore_open_info_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 %ssharedSemaphore = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedSemaphore)); + 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_queue_semaphore_open_info_struct_wrapper::display_txt() +void xgl_pipeline_cb_attachment_state_struct_wrapper::display_txt() { - printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO 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_queue_semaphore_open_info_struct_wrapper::display_full_txt() +void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt() { - printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO 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_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_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_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_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_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_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_pipeline_cb_state_create_info_struct_wrapper::display_single_txt() +void xgl_vertex_input_binding_description_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_CB_STATE_CREATE_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_pipeline_cb_state_create_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 %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; idisplay_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_vertex_input_binding_description_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_CB_STATE_CREATE_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(); - uint32_t i; - for (i = 0; idisplay_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_shader_stage_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_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_memory_requirements_struct_wrapper class definition -xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* 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_buffer_memory_requirements_struct_wrapper::~xgl_buffer_memory_requirements_struct_wrapper() {} +xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_buffer_memory_requirements_struct_wrapper::display_single_txt() +void xgl_fence_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_BUFFER_MEMORY_REQUIREMENTS = %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_buffer_memory_requirements_struct_wrapper::display_struct_members() +void xgl_fence_create_info_struct_wrapper::display_struct_members() { - printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage)); + 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_buffer_memory_requirements_struct_wrapper::display_txt() +void xgl_fence_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS 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_buffer_memory_requirements_struct_wrapper::display_full_txt() +void xgl_fence_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS 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); + } } -// 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_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_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_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_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {} +xgl_framebuffer_create_info_struct_wrapper::~xgl_framebuffer_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_sampler_image_view_info_struct_wrapper::display_single_txt() +void xgl_framebuffer_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_SAMPLER_IMAGE_VIEW_INFO = %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_sampler_image_view_info_struct_wrapper::display_struct_members() +void xgl_framebuffer_create_info_struct_wrapper::display_struct_members() { - printf("%*s %spSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pSampler)); - printf("%*s %spImageView = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pImageView)); + 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; idisplay_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_framebuffer_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO 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.pImageView) { - xgl_image_view_attach_info_struct_wrapper class0(m_struct.pImageView); + 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; idisplay_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_extent2d_struct_wrapper::display_full_txt() { - printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO 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_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_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_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_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_event_wait_info_struct_wrapper::~xgl_event_wait_info_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_event_wait_info_struct_wrapper::display_single_txt() +void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_EVENT_WAIT_INFO = %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_event_wait_info_struct_wrapper::display_struct_members() +void xgl_compute_pipeline_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount)); - uint32_t i; - for (i = 0; idisplay_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_compute_pipeline_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); + if (&m_struct.cs) { + xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs); + class0.set_indent(m_indent + 4); + class0.display_full_txt(); + } if (m_struct.pNext) { dynamic_display_full_txt(m_struct.pNext, m_indent); } } -// xgl_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_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_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_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_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_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_descriptor_region_create_info_struct_wrapper::display_single_txt() +void xgl_image_subresource_range_struct_wrapper::display_single_txt() { - printf(" %*sXGL_DESCRIPTOR_REGION_CREATE_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_descriptor_region_create_info_struct_wrapper::display_struct_members() +void xgl_image_subresource_range_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; idisplay_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_image_subresource_range_struct_wrapper::display_full_txt() { - printf("%*sXGL_DESCRIPTOR_REGION_CREATE_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(); - uint32_t i; - for (i = 0; idisplay_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_pipeline_tess_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_MEMORY_ALLOC_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); @@ -1967,90 +1950,86 @@ void xgl_memory_alloc_info_struct_wrapper::display_full_txt() } -// 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_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_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_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_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {} +xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_memory_open_info_struct_wrapper::display_single_txt() +void xgl_offset2d_struct_wrapper::display_single_txt() { - printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr); + printf(" %*sXGL_OFFSET2D = %p", m_indent, "", (void*)m_origStructAddr); } // Private helper function that displays the members of the wrapped struct -void xgl_memory_open_info_struct_wrapper::display_struct_members() +void xgl_offset2d_struct_wrapper::display_struct_members() { - printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); - printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem)); + 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_memory_open_info_struct_wrapper::display_txt() +void xgl_offset2d_struct_wrapper::display_txt() { - printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); } // Output all struct elements, and for any structs pointed to, print complete contents -void xgl_memory_open_info_struct_wrapper::display_full_txt() +void xgl_offset2d_struct_wrapper::display_full_txt() { - printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); - if (m_struct.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); - } } -// xgl_graphics_pipeline_create_info_struct_wrapper class definition -xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +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_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_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_graphics_pipeline_create_info_struct_wrapper::display_single_txt() +void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %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_graphics_pipeline_create_info_struct_wrapper::display_struct_members() +void xgl_queue_semaphore_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); + printf("%*s %sinitialCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.initialCount)); printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags)); - printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout)); } // Output all struct elements, each on their own line -void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt() +void xgl_queue_semaphore_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO 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_graphics_pipeline_create_info_struct_wrapper::display_full_txt() +void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_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); @@ -2058,50 +2037,95 @@ void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt() } -// 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_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_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_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_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {} +xgl_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt() +void xgl_clear_color_value_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %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_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members() +void xgl_clear_color_value_struct_wrapper::display_struct_members() +{ + uint32_t i; + for (i = 0; i<4; i++) { + printf("%*s %sfloatColor[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.floatColor)[i]); + } + for (i = 0; i<4; i++) { + printf("%*s %srawColor[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.rawColor)[i]); + } +} + +// Output all struct elements, each on their own line +void xgl_clear_color_value_struct_wrapper::display_txt() +{ + printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + this->display_struct_members(); +} + +// Output all struct elements, and for any structs pointed to, print complete contents +void xgl_clear_color_value_struct_wrapper::display_full_txt() +{ + printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + this->display_struct_members(); +} + + +// xgl_buffer_memory_barrier_struct_wrapper class definition +xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0') +{ + m_struct = *pInStruct; + m_origStructAddr = pInStruct; +} +xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0') +{ + m_struct = *pInStruct; + m_origStructAddr = pInStruct; +} +xgl_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {} +// Output 'structname = struct_address' on a single line +void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt() +{ + printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr); +} + +// Private helper function that displays the members of the wrapped struct +void xgl_buffer_memory_barrier_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.shader)); + 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_pipeline_shader_stage_create_info_struct_wrapper::display_txt() +void xgl_buffer_memory_barrier_struct_wrapper::display_txt() { - printf("%*sXGL_PIPELINE_SHADER_STAGE_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_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt() +void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_SHADER_STAGE_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(); - 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); } @@ -2157,53 +2181,51 @@ void xgl_pipeline_ms_state_create_info_struct_wrapper::display_full_txt() } -// 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_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_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* 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_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_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_pipeline_barrier_struct_wrapper::display_single_txt() +void xgl_pipeline_rs_state_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_BARRIER = %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_pipeline_barrier_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 %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount)); - uint32_t i; - for (i = 0; idisplay_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_pipeline_rs_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_BARRIER 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.pNext) { dynamic_display_full_txt(m_struct.pNext, m_indent); @@ -2211,236 +2233,265 @@ void xgl_pipeline_barrier_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_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_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* 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_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {} +xgl_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_memory_barrier_struct_wrapper::display_single_txt() +void xgl_image_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_MEMORY_BARRIER = %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_memory_barrier_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 %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 %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_memory_barrier_struct_wrapper::display_txt() +void xgl_image_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_MEMORY_BARRIER 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_memory_barrier_struct_wrapper::display_full_txt() +void xgl_image_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_MEMORY_BARRIER 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_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_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_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_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_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {} +xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt() +void xgl_update_images_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_IA_STATE_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_pipeline_ia_state_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 %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 %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; idisplay_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_update_images_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_IA_STATE_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; idisplay_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_cmd_buffer_begin_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE 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_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_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_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_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_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_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_cmd_buffer_create_info_struct_wrapper::display_single_txt() +void xgl_image_view_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %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_cmd_buffer_create_info_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 %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 %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_cmd_buffer_create_info_struct_wrapper::display_txt() +void xgl_image_view_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + 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_cmd_buffer_create_info_struct_wrapper::display_full_txt() +void xgl_image_view_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + 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_application_info_struct_wrapper class definition -xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// xgl_graphics_pipeline_create_info_struct_wrapper class definition +xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {} +xgl_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_application_info_struct_wrapper::display_single_txt() +void xgl_graphics_pipeline_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_APPLICATION_INFO = %p", m_indent, "", (void*)m_origStructAddr); + printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr); } // Private helper function that displays the members of the wrapped struct -void xgl_application_info_struct_wrapper::display_struct_members() +void xgl_graphics_pipeline_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName)); - printf("%*s %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion)); - printf("%*s %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName)); - printf("%*s %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion)); - printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion)); + printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags)); + printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout)); } // Output all struct elements, each on their own line -void xgl_application_info_struct_wrapper::display_txt() +void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); } // Output all struct elements, and for any structs pointed to, print complete contents -void xgl_application_info_struct_wrapper::display_full_txt() +void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); if (m_struct.pNext) { dynamic_display_full_txt(m_struct.pNext, m_indent); @@ -2448,354 +2499,458 @@ void xgl_application_info_struct_wrapper::display_full_txt() } -// 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_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_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_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_pipeline_rs_state_create_info_struct_wrapper::~xgl_pipeline_rs_state_create_info_struct_wrapper() {} +xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_pipeline_rs_state_create_info_struct_wrapper::display_single_txt() +void xgl_rect_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_RS_STATE_CREATE_INFO = %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_pipeline_rs_state_create_info_struct_wrapper::display_struct_members() +void xgl_rect_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 %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_pipeline_rs_state_create_info_struct_wrapper::display_txt() +void xgl_rect_struct_wrapper::display_txt() { - printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO 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_pipeline_rs_state_create_info_struct_wrapper::display_full_txt() +void xgl_rect_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO 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.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); + 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_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_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_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_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_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_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_color_attachment_view_create_info_struct_wrapper::display_single_txt() +void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_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_color_attachment_view_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 %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 %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass)); } // Output all struct elements, each on their own line -void xgl_color_attachment_view_create_info_struct_wrapper::display_txt() +void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt() { - printf("%*sXGL_COLOR_ATTACHMENT_VIEW_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_color_attachment_view_create_info_struct_wrapper::display_full_txt() +void xgl_cmd_buffer_graphics_begin_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_CMD_BUFFER_GRAPHICS_BEGIN_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_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_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_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_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_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_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_image_memory_bind_info_struct_wrapper::display_single_txt() +void xgl_device_queue_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_MEMORY_BIND_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_image_memory_bind_info_struct_wrapper::display_struct_members() +void xgl_device_queue_create_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 %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_image_memory_bind_info_struct_wrapper::display_txt() +void xgl_device_queue_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_IMAGE_MEMORY_BIND_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_image_memory_bind_info_struct_wrapper::display_full_txt() +void xgl_device_queue_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_MEMORY_BIND_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.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_memory_open_info_struct_wrapper class definition +xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +{ + m_struct = *pInStruct; + m_origStructAddr = pInStruct; +} +xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +{ + m_struct = *pInStruct; + m_origStructAddr = pInStruct; +} +xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {} +// Output 'structname = struct_address' on a single line +void xgl_memory_open_info_struct_wrapper::display_single_txt() +{ + printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr); +} + +// Private helper function that displays the members of the wrapped struct +void xgl_memory_open_info_struct_wrapper::display_struct_members() +{ + printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); + printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); + printf("%*s %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem)); +} + +// Output all struct elements, each on their own line +void xgl_memory_open_info_struct_wrapper::display_txt() +{ + printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + this->display_struct_members(); +} + +// Output all struct elements, and for any structs pointed to, print complete contents +void xgl_memory_open_info_struct_wrapper::display_full_txt() +{ + printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + this->display_struct_members(); + if (m_struct.pNext) { + dynamic_display_full_txt(m_struct.pNext, m_indent); } } -// xgl_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_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_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* 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_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {} +xgl_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_image_subresource_struct_wrapper::display_single_txt() +void xgl_update_as_copy_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_SUBRESOURCE = %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_image_subresource_struct_wrapper::display_struct_members() +void xgl_update_as_copy_struct_wrapper::display_struct_members() { - printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect)); - printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel)); - printf("%*s %sarraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySlice)); + printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); + printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); + printf("%*s %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_image_subresource_struct_wrapper::display_txt() +void xgl_update_as_copy_struct_wrapper::display_txt() { - printf("%*sXGL_IMAGE_SUBRESOURCE 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_image_subresource_struct_wrapper::display_full_txt() +void xgl_update_as_copy_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_SUBRESOURCE 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); + } } -// 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_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_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_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_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {} +xgl_image_copy_struct_wrapper::~xgl_image_copy_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt() +void xgl_image_copy_struct_wrapper::display_single_txt() { - printf(" %*sXGL_DRAW_INDIRECT_CMD = %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_draw_indirect_cmd_struct_wrapper::display_struct_members() +void xgl_image_copy_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 %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_draw_indirect_cmd_struct_wrapper::display_txt() +void xgl_image_copy_struct_wrapper::display_txt() { - printf("%*sXGL_DRAW_INDIRECT_CMD 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_draw_indirect_cmd_struct_wrapper::display_full_txt() +void xgl_image_copy_struct_wrapper::display_full_txt() { - printf("%*sXGL_DRAW_INDIRECT_CMD 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_extent3d_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); + 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_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') +// 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_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') +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_view_create_info_struct_wrapper::~xgl_image_view_create_info_struct_wrapper() {} +xgl_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_image_view_create_info_struct_wrapper::display_single_txt() +void xgl_image_resolve_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr); + printf(" %*sXGL_IMAGE_RESOLVE = %p", m_indent, "", (void*)m_origStructAddr); } // Private helper function that displays the members of the wrapped struct -void xgl_image_view_create_info_struct_wrapper::display_struct_members() +void xgl_image_resolve_struct_wrapper::display_struct_members() { - printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); - printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %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)); + printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource)); + printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset)); + printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource)); + printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset)); + printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent)); } // Output all struct elements, each on their own line -void xgl_image_view_create_info_struct_wrapper::display_txt() +void xgl_image_resolve_struct_wrapper::display_txt() { - printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); } // Output all struct elements, and for any structs pointed to, print complete contents -void xgl_image_view_create_info_struct_wrapper::display_full_txt() +void xgl_image_resolve_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); - if (&m_struct.subresourceRange) { - xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange); + 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.channels) { - xgl_channel_mapping_struct_wrapper class1(&m_struct.channels); + 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.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); + 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_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_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_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_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_cmd_buffer_begin_info_struct_wrapper::~xgl_cmd_buffer_begin_info_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_cmd_buffer_begin_info_struct_wrapper::display_single_txt() +void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_CMD_BUFFER_BEGIN_INFO = %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_cmd_buffer_begin_info_struct_wrapper::display_struct_members() +void xgl_color_attachment_bind_info_struct_wrapper::display_struct_members() +{ + printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view)); + printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout)); +} + +// Output all struct elements, each on their own line +void xgl_color_attachment_bind_info_struct_wrapper::display_txt() +{ + printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + this->display_struct_members(); +} + +// Output all struct elements, and for any structs pointed to, print complete contents +void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt() +{ + printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + this->display_struct_members(); +} + + +// xgl_dynamic_ds_state_create_info_struct_wrapper class definition +xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +{ + m_struct = *pInStruct; + m_origStructAddr = pInStruct; +} +xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +{ + m_struct = *pInStruct; + m_origStructAddr = pInStruct; +} +xgl_dynamic_ds_state_create_info_struct_wrapper::~xgl_dynamic_ds_state_create_info_struct_wrapper() {} +// Output 'structname = struct_address' on a single line +void xgl_dynamic_ds_state_create_info_struct_wrapper::display_single_txt() +{ + printf(" %*sXGL_DYNAMIC_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr); +} + +// Private helper function that displays the members of the wrapped struct +void xgl_dynamic_ds_state_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags)); + 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_cmd_buffer_begin_info_struct_wrapper::display_txt() +void xgl_dynamic_ds_state_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_CMD_BUFFER_BEGIN_INFO 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_cmd_buffer_begin_info_struct_wrapper::display_full_txt() +void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_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); @@ -2803,171 +2958,171 @@ void xgl_cmd_buffer_begin_info_struct_wrapper::display_full_txt() } -// 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_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_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* 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_image_copy_struct_wrapper::~xgl_image_copy_struct_wrapper() {} +xgl_image_memory_barrier_struct_wrapper::~xgl_image_memory_barrier_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_image_copy_struct_wrapper::display_single_txt() +void xgl_image_memory_barrier_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_COPY = %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_image_copy_struct_wrapper::display_struct_members() +void xgl_image_memory_barrier_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 %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_image_copy_struct_wrapper::display_txt() +void xgl_image_memory_barrier_struct_wrapper::display_txt() { - printf("%*sXGL_IMAGE_COPY 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_image_copy_struct_wrapper::display_full_txt() +void xgl_image_memory_barrier_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_COPY 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.extent) { - xgl_extent3d_struct_wrapper class0(&m_struct.extent); + 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.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(); + if (m_struct.pNext) { + dynamic_display_full_txt(m_struct.pNext, m_indent); } } -// xgl_pipeline_vp_state_create_info_struct_wrapper class definition -xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// xgl_pipeline_ds_state_create_info_struct_wrapper class definition +xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_pipeline_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_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_pipeline_vp_state_create_info_struct_wrapper::~xgl_pipeline_vp_state_create_info_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_pipeline_vp_state_create_info_struct_wrapper::display_single_txt() +void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_VP_STATE_CREATE_INFO = %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_pipeline_vp_state_create_info_struct_wrapper::display_struct_members() +void xgl_pipeline_ds_state_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %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 %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format)); + printf("%*s %sdepthTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthTestEnable) ? "TRUE" : "FALSE"); + printf("%*s %sdepthWriteEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthWriteEnable) ? "TRUE" : "FALSE"); + printf("%*s %sdepthFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.depthFunc)); + printf("%*s %sdepthBoundsEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBoundsEnable) ? "TRUE" : "FALSE"); + printf("%*s %sstencilTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilTestEnable) ? "TRUE" : "FALSE"); + printf("%*s %sfront = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.front)); + printf("%*s %sback = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.back)); } // Output all struct elements, each on their own line -void xgl_pipeline_vp_state_create_info_struct_wrapper::display_txt() +void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO 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_pipeline_vp_state_create_info_struct_wrapper::display_full_txt() +void xgl_pipeline_ds_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + 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_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_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_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_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_image_memory_barrier_struct_wrapper::~xgl_image_memory_barrier_struct_wrapper() {} +xgl_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_image_memory_barrier_struct_wrapper::display_single_txt() +void xgl_pipeline_barrier_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_MEMORY_BARRIER = %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_image_memory_barrier_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 %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)); + printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount)); + uint32_t i; + for (i = 0; idisplay_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_pipeline_barrier_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_MEMORY_BARRIER 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.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); } @@ -3015,44 +3170,46 @@ void xgl_physical_gpu_memory_properties_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_memory_alloc_image_info_struct_wrapper class definition +xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_memory_alloc_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_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_memory_alloc_buffer_info_struct_wrapper::~xgl_memory_alloc_buffer_info_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_memory_alloc_buffer_info_struct_wrapper::display_single_txt() +void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_MEMORY_ALLOC_BUFFER_INFO = %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_memory_alloc_buffer_info_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 %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage)); + printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass)); + printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples)); } // Output all struct elements, each on their own line -void xgl_memory_alloc_buffer_info_struct_wrapper::display_txt() +void xgl_memory_alloc_image_info_struct_wrapper::display_txt() { - printf("%*sXGL_MEMORY_ALLOC_BUFFER_INFO 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_memory_alloc_buffer_info_struct_wrapper::display_full_txt() +void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_MEMORY_ALLOC_BUFFER_INFO 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); @@ -3060,54 +3217,55 @@ void xgl_memory_alloc_buffer_info_struct_wrapper::display_full_txt() } -// 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_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_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_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_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_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_compute_pipeline_create_info_struct_wrapper::display_single_txt() +void xgl_update_sampler_textures_struct_wrapper::display_single_txt() { - printf(" %*sXGL_COMPUTE_PIPELINE_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_compute_pipeline_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 %scs = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.cs)); - printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags)); - printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout)); - printf("%*s %slocalSizeX = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeX)); - printf("%*s %slocalSizeY = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeY)); - printf("%*s %slocalSizeZ = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeZ)); + printf("%*s %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; idisplay_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_update_sampler_textures_struct_wrapper::display_full_txt() { - printf("%*sXGL_COMPUTE_PIPELINE_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(); - if (&m_struct.cs) { - xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs); - class0.set_indent(m_indent + 4); - class0.display_full_txt(); + uint32_t i; + for (i = 0; idisplay_struct_members(); -} - -// Output all struct elements, and for any structs pointed to, print complete contents -void xgl_channel_mapping_struct_wrapper::display_full_txt() -{ - printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); - this->display_struct_members(); -} - - -// xgl_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_peer_memory_open_info_struct_wrapper class definition +xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_peer_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_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_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_peer_image_open_info_struct_wrapper::display_single_txt() +void xgl_peer_memory_open_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PEER_IMAGE_OPEN_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_peer_image_open_info_struct_wrapper::display_struct_members() +void xgl_peer_memory_open_info_struct_wrapper::display_struct_members() { - printf("%*s %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage)); + printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); + printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); + printf("%*s %soriginalMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalMem)); } // Output all struct elements, each on their own line -void xgl_peer_image_open_info_struct_wrapper::display_txt() +void xgl_peer_memory_open_info_struct_wrapper::display_txt() { - printf("%*sXGL_PEER_IMAGE_OPEN_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_peer_image_open_info_struct_wrapper::display_full_txt() +void xgl_peer_memory_open_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_PEER_IMAGE_OPEN_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.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_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_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_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_dynamic_vp_state_create_info_struct_wrapper::~xgl_dynamic_vp_state_create_info_struct_wrapper() {} +xgl_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt() +void xgl_descriptor_type_count_struct_wrapper::display_single_txt() { - printf(" %*sXGL_DYNAMIC_VP_STATE_CREATE_INFO = %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_dynamic_vp_state_create_info_struct_wrapper::display_struct_members() +void xgl_descriptor_type_count_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; idisplay_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_descriptor_type_count_struct_wrapper::display_full_txt() { - printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO 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(); - uint32_t i; - for (i = 0; idisplay_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_dispatch_indirect_cmd_struct_wrapper::display_full_txt() { - printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE 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(); } -// 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_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_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_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_render_pass_create_info_struct_wrapper::~xgl_render_pass_create_info_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_render_pass_create_info_struct_wrapper::display_single_txt() +void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_RENDER_PASS_CREATE_INFO = %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_render_pass_create_info_struct_wrapper::display_struct_members() +void xgl_descriptor_region_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %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 %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count)); uint32_t i; - for (i = 0; idisplay_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_descriptor_region_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_RENDER_PASS_CREATE_INFO 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; idisplay_struct_members(); -} - -// Output all struct elements, and for any structs pointed to, print complete contents -void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt() -{ - printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); - this->display_struct_members(); - if (m_struct.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); - } -} - - -// xgl_buffer_create_info_struct_wrapper class definition -xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_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_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_buffer_create_info_struct_wrapper::~xgl_buffer_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_buffer_create_info_struct_wrapper::display_single_txt() +void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_BUFFER_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_buffer_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 %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 %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_buffer_create_info_struct_wrapper::display_txt() +void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_BUFFER_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_buffer_create_info_struct_wrapper::display_full_txt() +void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_BUFFER_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(); + 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_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_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_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_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_cmd_buffer_graphics_begin_info_struct_wrapper::~xgl_cmd_buffer_graphics_begin_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_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt() +void xgl_query_pool_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_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_cmd_buffer_graphics_begin_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 %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass)); + 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_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt() +void xgl_query_pool_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_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_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt() +void xgl_query_pool_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_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); @@ -3566,99 +3603,45 @@ void xgl_cmd_buffer_graphics_begin_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') -{ - m_struct = *pInStruct; - m_origStructAddr = pInStruct; -} -xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(const XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0') -{ - m_struct = *pInStruct; - m_origStructAddr = pInStruct; -} -xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {} -// Output 'structname = struct_address' on a single line -void xgl_rect_struct_wrapper::display_single_txt() -{ - printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr); -} - -// Private helper function that displays the members of the wrapped struct -void xgl_rect_struct_wrapper::display_struct_members() -{ - printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset)); - printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent)); -} - -// Output all struct elements, each on their own line -void xgl_rect_struct_wrapper::display_txt() -{ - printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); - this->display_struct_members(); -} - -// Output all struct elements, and for any structs pointed to, print complete contents -void xgl_rect_struct_wrapper::display_full_txt() -{ - printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); - this->display_struct_members(); - if (&m_struct.extent) { - xgl_extent2d_struct_wrapper class0(&m_struct.extent); - class0.set_indent(m_indent + 4); - class0.display_full_txt(); - } - if (&m_struct.offset) { - xgl_offset2d_struct_wrapper class1(&m_struct.offset); - class1.set_indent(m_indent + 4); - class1.display_full_txt(); - } -} - - -// xgl_buffer_memory_barrier_struct_wrapper class definition -xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_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_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_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_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_buffer_memory_barrier_struct_wrapper::display_single_txt() +void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %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_buffer_memory_barrier_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 %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 %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_buffer_memory_barrier_struct_wrapper::display_txt() +void xgl_cmd_buffer_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_BUFFER_MEMORY_BARRIER 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_buffer_memory_barrier_struct_wrapper::display_full_txt() +void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_BUFFER_MEMORY_BARRIER 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(); if (m_struct.pNext) { dynamic_display_full_txt(m_struct.pNext, m_indent); @@ -3666,204 +3649,175 @@ void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt() } -// 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_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_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_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_pipeline_ds_state_create_info_struct_wrapper::~xgl_pipeline_ds_state_create_info_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_pipeline_ds_state_create_info_struct_wrapper::display_single_txt() +void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_DS_STATE_CREATE_INFO = %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_pipeline_ds_state_create_info_struct_wrapper::display_struct_members() +void xgl_depth_stencil_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 %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 %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_pipeline_ds_state_create_info_struct_wrapper::display_txt() +void xgl_depth_stencil_bind_info_struct_wrapper::display_txt() { - printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO 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_pipeline_ds_state_create_info_struct_wrapper::display_full_txt() +void xgl_depth_stencil_bind_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_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); - if (&m_struct.back) { - xgl_stencil_op_state_struct_wrapper class0(&m_struct.back); - class0.set_indent(m_indent + 4); - class0.display_full_txt(); - } - if (&m_struct.front) { - xgl_stencil_op_state_struct_wrapper class1(&m_struct.front); - class1.set_indent(m_indent + 4); - class1.display_full_txt(); - } - if (m_struct.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); - } } -// xgl_descriptor_type_count_struct_wrapper class definition -xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_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_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_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_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_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_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_update_sampler_textures_struct_wrapper::display_single_txt() +void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %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_update_sampler_textures_struct_wrapper::display_struct_members() +void xgl_queue_semaphore_open_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %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; idisplay_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_queue_semaphore_open_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_UPDATE_SAMPLER_TEXTURES 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(); - uint32_t i; - for (i = 0; idisplay_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_memory_barrier_struct_wrapper::display_full_txt() { - printf("%*sXGL_QUERY_POOL_CREATE_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); @@ -3871,1069 +3825,1103 @@ void xgl_query_pool_create_info_struct_wrapper::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_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_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_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_event_create_info_struct_wrapper::~xgl_event_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_event_create_info_struct_wrapper::display_single_txt() +void xgl_physical_gpu_performance_struct_wrapper::display_single_txt() { - printf(" %*sXGL_EVENT_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_event_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 %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_event_create_info_struct_wrapper::display_txt() +void xgl_physical_gpu_performance_struct_wrapper::display_txt() { - printf("%*sXGL_EVENT_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_event_create_info_struct_wrapper::display_full_txt() +void xgl_physical_gpu_performance_struct_wrapper::display_full_txt() { - printf("%*sXGL_EVENT_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_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_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_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* 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_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {} +xgl_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_offset2d_struct_wrapper::display_single_txt() +void xgl_channel_mapping_struct_wrapper::display_single_txt() { - printf(" %*sXGL_OFFSET2D = %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_offset2d_struct_wrapper::display_struct_members() +void xgl_channel_mapping_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 %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_offset2d_struct_wrapper::display_txt() +void xgl_channel_mapping_struct_wrapper::display_txt() { - printf("%*sXGL_OFFSET2D 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_offset2d_struct_wrapper::display_full_txt() +void xgl_channel_mapping_struct_wrapper::display_full_txt() { - printf("%*sXGL_OFFSET2D 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(); } -// 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_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_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* 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_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {} +xgl_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_update_buffers_struct_wrapper::display_single_txt() +void xgl_clear_color_struct_wrapper::display_single_txt() { - printf(" %*sXGL_UPDATE_BUFFERS = %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_update_buffers_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 %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; idisplay_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_clear_color_struct_wrapper::display_full_txt() { - printf("%*sXGL_UPDATE_BUFFERS 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(); - uint32_t i; - for (i = 0; idisplay_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_dynamic_cb_state_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_MEMORY_REF 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.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_buffer_view_create_info_struct_wrapper class definition +xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_buffer_view_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_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_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_buffer_view_attach_info_struct_wrapper::display_single_txt() +void xgl_buffer_view_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_BUFFER_VIEW_ATTACH_INFO = %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_buffer_view_attach_info_struct_wrapper::display_struct_members() +void xgl_buffer_view_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view)); + printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer)); + printf("%*s %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BUFFER_VIEW_TYPE(m_struct.viewType)); + printf("%*s %sstride = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.stride)); + printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format)); + printf("%*s %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels)); + printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset)); + printf("%*s %srange = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.range)); } // Output all struct elements, each on their own line -void xgl_buffer_view_attach_info_struct_wrapper::display_txt() +void xgl_buffer_view_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO 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_buffer_view_attach_info_struct_wrapper::display_full_txt() +void xgl_buffer_view_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO 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_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_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_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_pipeline_vertex_input_create_info_struct_wrapper::~xgl_pipeline_vertex_input_create_info_struct_wrapper() {} +xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt() +void xgl_sampler_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO = %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_pipeline_vertex_input_create_info_struct_wrapper::display_struct_members() +void xgl_sampler_create_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %sbindingCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bindingCount)); - uint32_t i; - for (i = 0; idisplay_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_sampler_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO 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(); - uint32_t i; - for (i = 0; idisplay_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_event_wait_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_GPU_COMPATIBILITY_INFO 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_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_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_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_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_shader_create_info_struct_wrapper::~xgl_shader_create_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_shader_create_info_struct_wrapper::display_single_txt() +void xgl_buffer_image_copy_struct_wrapper::display_single_txt() { - printf(" %*sXGL_SHADER_CREATE_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_shader_create_info_struct_wrapper::display_struct_members() +void xgl_buffer_image_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 %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 %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_shader_create_info_struct_wrapper::display_txt() +void xgl_buffer_image_copy_struct_wrapper::display_txt() { - printf("%*sXGL_SHADER_CREATE_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_shader_create_info_struct_wrapper::display_full_txt() +void xgl_buffer_image_copy_struct_wrapper::display_full_txt() { - printf("%*sXGL_SHADER_CREATE_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.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); + 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_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_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_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* 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_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {} +xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_offset3d_struct_wrapper::display_single_txt() +void xgl_event_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_OFFSET3D = %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_offset3d_struct_wrapper::display_struct_members() +void xgl_event_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 %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags)); } // Output all struct elements, each on their own line -void xgl_offset3d_struct_wrapper::display_txt() +void xgl_event_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_OFFSET3D 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_offset3d_struct_wrapper::display_full_txt() +void xgl_event_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_OFFSET3D 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); + } } -// 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_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_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_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_layer_create_info_struct_wrapper::~xgl_layer_create_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_layer_create_info_struct_wrapper::display_single_txt() +void xgl_physical_gpu_properties_struct_wrapper::display_single_txt() { - printf(" %*sXGL_LAYER_CREATE_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_layer_create_info_struct_wrapper::display_struct_members() +void xgl_physical_gpu_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 %slayerCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layerCount)); + 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; idisplay_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_physical_gpu_properties_struct_wrapper::display_full_txt() { - printf("%*sXGL_LAYER_CREATE_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(); - if (m_struct.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); - } } -// xgl_depth_stencil_view_create_info_struct_wrapper class definition -xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_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_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_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_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_depth_stencil_view_create_info_struct_wrapper::display_single_txt() +void xgl_image_view_attach_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_DEPTH_STENCIL_VIEW_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_depth_stencil_view_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 %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 %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view)); + printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout)); } // Output all struct elements, each on their own line -void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt() +void xgl_image_view_attach_info_struct_wrapper::display_txt() { - printf("%*sXGL_DEPTH_STENCIL_VIEW_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_depth_stencil_view_create_info_struct_wrapper::display_full_txt() +void xgl_image_view_attach_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_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); - if (&m_struct.msaaResolveSubResource) { - xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource); - class0.set_indent(m_indent + 4); - class0.display_full_txt(); - } if (m_struct.pNext) { dynamic_display_full_txt(m_struct.pNext, m_indent); } } -// xgl_depth_stencil_bind_info_struct_wrapper class definition -xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_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_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_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_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_depth_stencil_bind_info_struct_wrapper::display_single_txt() +void xgl_memory_alloc_buffer_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_DEPTH_STENCIL_BIND_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_depth_stencil_bind_info_struct_wrapper::display_struct_members() +void xgl_memory_alloc_buffer_info_struct_wrapper::display_struct_members() { - printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view)); - printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout)); + 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)); } // Output all struct elements, each on their own line -void xgl_depth_stencil_bind_info_struct_wrapper::display_txt() +void xgl_memory_alloc_buffer_info_struct_wrapper::display_txt() { - printf("%*sXGL_DEPTH_STENCIL_BIND_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_depth_stencil_bind_info_struct_wrapper::display_full_txt() +void xgl_memory_alloc_buffer_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_DEPTH_STENCIL_BIND_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.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_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_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_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_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {} +xgl_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_image_memory_requirements_struct_wrapper::display_single_txt() +void xgl_buffer_copy_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_MEMORY_REQUIREMENTS = %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_image_memory_requirements_struct_wrapper::display_struct_members() +void xgl_buffer_copy_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 %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_image_memory_requirements_struct_wrapper::display_txt() +void xgl_buffer_copy_struct_wrapper::display_txt() { - printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS 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_image_memory_requirements_struct_wrapper::display_full_txt() +void xgl_buffer_copy_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS 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_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_image_memory_bind_info_struct_wrapper class definition +xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} +xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') { m_struct = *pInStruct; m_origStructAddr = pInStruct; } -xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* 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_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_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_image_subresource_range_struct_wrapper::display_single_txt() +void xgl_image_memory_bind_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %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_image_subresource_range_struct_wrapper::display_struct_members() +void xgl_image_memory_bind_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 %ssubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresource)); + printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset)); + printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent)); } // Output all struct elements, each on their own line -void xgl_image_subresource_range_struct_wrapper::display_txt() +void xgl_image_memory_bind_info_struct_wrapper::display_txt() { - printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE 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_image_subresource_range_struct_wrapper::display_full_txt() +void xgl_image_memory_bind_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE 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.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_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_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_images_struct_wrapper::xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* 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_images_struct_wrapper::~xgl_update_images_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_images_struct_wrapper::display_single_txt() +void xgl_image_memory_requirements_struct_wrapper::display_single_txt() { - printf(" %*sXGL_UPDATE_IMAGES = %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_images_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 %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; idisplay_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_image_memory_requirements_struct_wrapper::display_full_txt() { - printf("%*sXGL_UPDATE_IMAGES 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(); - uint32_t i; - for (i = 0; idisplay_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_pipeline_shader_struct_wrapper::display_full_txt() { - printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); + uint32_t i; + for (i = 0; idisplay_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_offset3d_struct_wrapper::display_full_txt() { - printf("%*sXGL_EXTENT3D 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(); } -// 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_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_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_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_clear_color_value_struct_wrapper::~xgl_clear_color_value_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_clear_color_value_struct_wrapper::display_single_txt() +void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_CLEAR_COLOR_VALUE = %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_clear_color_value_struct_wrapper::display_struct_members() +void xgl_buffer_view_attach_info_struct_wrapper::display_struct_members() { - uint32_t i; - for (i = 0; i<4; i++) { - printf("%*s %sfloatColor[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.floatColor)[i]); - } - for (i = 0; i<4; i++) { - printf("%*s %srawColor[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.rawColor)[i]); - } + printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); + printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); + printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view)); } // Output all struct elements, each on their own line -void xgl_clear_color_value_struct_wrapper::display_txt() +void xgl_buffer_view_attach_info_struct_wrapper::display_txt() { - printf("%*sXGL_CLEAR_COLOR_VALUE 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_clear_color_value_struct_wrapper::display_full_txt() +void xgl_buffer_view_attach_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_CLEAR_COLOR_VALUE 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(); + 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_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_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_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_memory_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {} +xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt() +void xgl_extent3d_struct_wrapper::display_single_txt() { - printf(" %*sXGL_MEMORY_ALLOC_IMAGE_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_memory_alloc_image_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 %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 %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_memory_alloc_image_info_struct_wrapper::display_txt() +void xgl_extent3d_struct_wrapper::display_txt() { - printf("%*sXGL_MEMORY_ALLOC_IMAGE_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_memory_alloc_image_info_struct_wrapper::display_full_txt() +void xgl_extent3d_struct_wrapper::display_full_txt() { - printf("%*sXGL_MEMORY_ALLOC_IMAGE_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_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_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_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_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_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_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_device_queue_create_info_struct_wrapper::display_single_txt() +void xgl_sampler_image_view_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_DEVICE_QUEUE_CREATE_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_device_queue_create_info_struct_wrapper::display_struct_members() +void xgl_sampler_image_view_info_struct_wrapper::display_struct_members() { - printf("%*s %squeueNodeIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueNodeIndex)); - printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount)); + 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_device_queue_create_info_struct_wrapper::display_txt() +void xgl_sampler_image_view_info_struct_wrapper::display_txt() { - printf("%*sXGL_DEVICE_QUEUE_CREATE_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_device_queue_create_info_struct_wrapper::display_full_txt() +void xgl_sampler_image_view_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_DEVICE_QUEUE_CREATE_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.pImageView) { + xgl_image_view_attach_info_struct_wrapper class0(m_struct.pImageView); + class0.set_indent(m_indent + 4); + class0.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') +// 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_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* 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_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {} +xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_stencil_op_state_struct_wrapper::display_single_txt() +void xgl_image_subresource_struct_wrapper::display_single_txt() { - printf(" %*sXGL_STENCIL_OP_STATE = %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_stencil_op_state_struct_wrapper::display_struct_members() +void xgl_image_subresource_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)); + 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_stencil_op_state_struct_wrapper::display_txt() +void xgl_image_subresource_struct_wrapper::display_txt() { - printf("%*sXGL_STENCIL_OP_STATE 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_stencil_op_state_struct_wrapper::display_full_txt() +void xgl_image_subresource_struct_wrapper::display_full_txt() { - printf("%*sXGL_STENCIL_OP_STATE 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(); } -// 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_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_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0') +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_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {} +xgl_layer_create_info_struct_wrapper::~xgl_layer_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_pipeline_shader_struct_wrapper::display_single_txt() +void xgl_layer_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_SHADER = %p", m_indent, "", (void*)m_origStructAddr); + printf(" %*sXGL_LAYER_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_layer_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 %slayerCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layerCount)); uint32_t i; - for (i = 0; idisplay_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_layer_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); - uint32_t i; - for (i = 0; idisplay_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_pipeline_vp_state_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_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); @@ -4941,291 +4929,303 @@ void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt() } -// 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_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_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_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_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {} +xgl_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt() +void xgl_buffer_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %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_pipeline_statistics_data_struct_wrapper::display_struct_members() +void xgl_buffer_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 %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_pipeline_statistics_data_struct_wrapper::display_txt() +void xgl_buffer_create_info_struct_wrapper::display_txt() { - printf("%*sXGL_PIPELINE_STATISTICS_DATA 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_pipeline_statistics_data_struct_wrapper::display_full_txt() +void xgl_buffer_create_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_STATISTICS_DATA 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); + } } -// 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_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_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_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_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_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_vertex_input_attribute_description_struct_wrapper::display_single_txt() +void xgl_render_pass_create_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION = %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_vertex_input_attribute_description_struct_wrapper::display_struct_members() +void xgl_render_pass_create_info_struct_wrapper::display_struct_members() { - printf("%*s %sbinding = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.binding)); - printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format)); - printf("%*s %soffsetInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offsetInBytes)); + 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; idisplay_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_render_pass_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_RENDER_PASS_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); + uint32_t i; + for (i = 0; idisplay_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_descriptor_set_layout_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_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); + if (m_struct.pNext) { + dynamic_display_full_txt(m_struct.pNext, m_indent); + } } -// xgl_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_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_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* 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_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {} +xgl_gpu_compatibility_info_struct_wrapper::~xgl_gpu_compatibility_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_update_samplers_struct_wrapper::display_single_txt() +void xgl_gpu_compatibility_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_UPDATE_SAMPLERS = %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_update_samplers_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 %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; idisplay_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_gpu_compatibility_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_UPDATE_SAMPLERS 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_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_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_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_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_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {} +xgl_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {} // Output 'structname = struct_address' on a single line -void xgl_image_create_info_struct_wrapper::display_single_txt() +void xgl_memory_alloc_info_struct_wrapper::display_single_txt() { - printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr); + printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr); } // Private helper function that displays the members of the wrapped struct -void xgl_image_create_info_struct_wrapper::display_struct_members() +void xgl_memory_alloc_info_struct_wrapper::display_struct_members() { printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType)); printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext)); - printf("%*s %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 %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_image_create_info_struct_wrapper::display_txt() +void xgl_memory_alloc_info_struct_wrapper::display_txt() { - printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); } // Output all struct elements, and for any structs pointed to, print complete contents -void xgl_image_create_info_struct_wrapper::display_full_txt() +void xgl_memory_alloc_info_struct_wrapper::display_full_txt() { - printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); - if (&m_struct.extent) { - xgl_extent3d_struct_wrapper class0(&m_struct.extent); - class0.set_indent(m_indent + 4); - class0.display_full_txt(); - } if (m_struct.pNext) { dynamic_display_full_txt(m_struct.pNext, m_indent); } } -// xgl_pipeline_tess_state_create_info_struct_wrapper class definition -xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {} -xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0') +// 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_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_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_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_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_pipeline_tess_state_create_info_struct_wrapper::display_single_txt() +void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt() { - printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %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_pipeline_tess_state_create_info_struct_wrapper::display_struct_members() +void xgl_physical_gpu_queue_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 %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 %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_pipeline_tess_state_create_info_struct_wrapper::display_txt() +void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt() { - printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); } // Output all struct elements, and for any structs pointed to, print complete contents -void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt() +void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt() { - printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); + printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr); this->display_struct_members(); - if (m_struct.pNext) { - dynamic_display_full_txt(m_struct.pNext, m_indent); - } } //any footer info for class diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h index 3439d04..ac2fe0c 100644 --- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h +++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h @@ -7,29 +7,36 @@ #include //class declaration -class xgl_format_properties_struct_wrapper +class xgl_pipeline_ia_state_create_info_struct_wrapper { public: - xgl_format_properties_struct_wrapper(); - xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct); - xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct); + xgl_pipeline_ia_state_create_info_struct_wrapper(); + xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct); + xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct); - virtual ~xgl_format_properties_struct_wrapper(); + virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - XGL_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_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_FORMAT_PROPERTIES m_struct; - const XGL_FORMAT_PROPERTIES* 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(); @@ -38,33 +45,36 @@ private: //class declaration -class xgl_buffer_image_copy_struct_wrapper +class xgl_application_info_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_application_info_struct_wrapper(); + xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct); + xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct); - virtual ~xgl_buffer_image_copy_struct_wrapper(); + virtual ~xgl_application_info_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - XGL_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_STRUCTURE_TYPE get_sType() { return m_struct.sType; } + void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } + const void* get_pNext() { return m_struct.pNext; } + const char* get_pAppName() { return m_struct.pAppName; } + uint32_t get_appVersion() { return m_struct.appVersion; } + void set_appVersion(uint32_t inValue) { m_struct.appVersion = inValue; } + const char* get_pEngineName() { return m_struct.pEngineName; } + uint32_t get_engineVersion() { return m_struct.engineVersion; } + void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; } + uint32_t get_apiVersion() { return m_struct.apiVersion; } + void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; } private: - XGL_BUFFER_IMAGE_COPY m_struct; - const XGL_BUFFER_IMAGE_COPY* m_origStructAddr; + XGL_APPLICATION_INFO m_struct; + const XGL_APPLICATION_INFO* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -73,14 +83,46 @@ private: //class declaration -class xgl_peer_memory_open_info_struct_wrapper +class xgl_link_const_buffer_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_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_peer_memory_open_info_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; } + uint32_t get_bufferId() { return m_struct.bufferId; } + void set_bufferId(uint32_t inValue) { m_struct.bufferId = inValue; } + size_t get_bufferSize() { return m_struct.bufferSize; } + void set_bufferSize(size_t inValue) { m_struct.bufferSize = inValue; } + const void* get_pBufferData() { return m_struct.pBufferData; } + + +private: + XGL_LINK_CONST_BUFFER m_struct; + const XGL_LINK_CONST_BUFFER* m_origStructAddr; + uint32_t m_indent; + const char m_dummy_prefix; + void display_struct_members(); + +}; + + +//class declaration +class xgl_update_samplers_struct_wrapper +{ +public: + xgl_update_samplers_struct_wrapper(); + xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct); + xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct); + + virtual ~xgl_update_samplers_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -90,13 +132,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; } + 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_PEER_MEMORY_OPEN_INFO m_struct; - const XGL_PEER_MEMORY_OPEN_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(); @@ -105,33 +149,33 @@ private: //class declaration -class xgl_subresource_layout_struct_wrapper +class xgl_stencil_op_state_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_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_subresource_layout_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_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; } + 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_SUBRESOURCE_LAYOUT m_struct; - const XGL_SUBRESOURCE_LAYOUT* 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(); @@ -140,33 +184,27 @@ private: //class declaration -class xgl_physical_gpu_queue_properties_struct_wrapper +class xgl_peer_image_open_info_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_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_physical_gpu_queue_properties_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_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; } + XGL_IMAGE get_originalImage() { return m_struct.originalImage; } + void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; } private: - XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct; - const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* 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(); @@ -175,14 +213,14 @@ private: //class declaration -class xgl_sampler_create_info_struct_wrapper +class xgl_device_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_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_sampler_create_info_struct_wrapper(); + virtual ~xgl_device_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -192,35 +230,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_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_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_SAMPLER_CREATE_INFO m_struct; - const XGL_SAMPLER_CREATE_INFO* 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(); @@ -229,35 +251,27 @@ private: //class declaration -class xgl_draw_indexed_indirect_cmd_struct_wrapper +class xgl_buffer_memory_requirements_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_buffer_memory_requirements_struct_wrapper(); + xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct); + xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct); - virtual ~xgl_draw_indexed_indirect_cmd_struct_wrapper(); + virtual ~xgl_buffer_memory_requirements_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - 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_FLAGS get_usage() { return m_struct.usage; } + void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; } private: - XGL_DRAW_INDEXED_INDIRECT_CMD m_struct; - const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr; + XGL_BUFFER_MEMORY_REQUIREMENTS m_struct; + const XGL_BUFFER_MEMORY_REQUIREMENTS* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -266,14 +280,14 @@ private: //class declaration -class xgl_update_as_copy_struct_wrapper +class xgl_update_buffers_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); + xgl_update_buffers_struct_wrapper(); + xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct); + xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct); - virtual ~xgl_update_as_copy_struct_wrapper(); + virtual ~xgl_update_buffers_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -285,17 +299,15 @@ public: 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_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_AS_COPY m_struct; - const XGL_UPDATE_AS_COPY* 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(); @@ -304,29 +316,31 @@ private: //class declaration -class xgl_clear_color_struct_wrapper +class xgl_vertex_input_attribute_description_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_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_clear_color_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_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; } + 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_CLEAR_COLOR m_struct; - const XGL_CLEAR_COLOR* 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(); @@ -335,29 +349,32 @@ private: //class declaration -class xgl_extent2d_struct_wrapper +class xgl_pipeline_vertex_input_create_info_struct_wrapper { public: - xgl_extent2d_struct_wrapper(); - xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct); - xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct); + xgl_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_extent2d_struct_wrapper(); + 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; } - 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; } + 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_EXTENT2D m_struct; - const XGL_EXTENT2D* m_origStructAddr; + 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(); @@ -366,14 +383,14 @@ private: //class declaration -class xgl_framebuffer_create_info_struct_wrapper +class xgl_dynamic_rs_state_create_info_struct_wrapper { public: - xgl_framebuffer_create_info_struct_wrapper(); - xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct); - xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct); + 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_framebuffer_create_info_struct_wrapper(); + virtual ~xgl_dynamic_rs_state_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -383,22 +400,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_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; } + 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_FRAMEBUFFER_CREATE_INFO m_struct; - const XGL_FRAMEBUFFER_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(); @@ -407,31 +425,33 @@ private: //class declaration -class xgl_alloc_callbacks_struct_wrapper +class xgl_subresource_layout_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_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_alloc_callbacks_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; } - 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_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_ALLOC_CALLBACKS m_struct; - const XGL_ALLOC_CALLBACKS* 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(); @@ -440,35 +460,35 @@ private: //class declaration -class xgl_memory_requirements_struct_wrapper +class xgl_draw_indexed_indirect_cmd_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_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_memory_requirements_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_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; } + 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_MEMORY_REQUIREMENTS m_struct; - const XGL_MEMORY_REQUIREMENTS* 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(); @@ -477,30 +497,30 @@ private: //class declaration -class xgl_link_const_buffer_struct_wrapper +class xgl_dynamic_vp_state_create_info_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_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_link_const_buffer_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; } - 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_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_LINK_CONST_BUFFER m_struct; - const XGL_LINK_CONST_BUFFER* 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(); @@ -509,53 +529,33 @@ private: //class declaration -class xgl_physical_gpu_properties_struct_wrapper +class xgl_shader_create_info_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_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_physical_gpu_properties_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; } - 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; } + 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_PHYSICAL_GPU_PROPERTIES m_struct; - const XGL_PHYSICAL_GPU_PROPERTIES* 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(); @@ -564,36 +564,29 @@ private: //class declaration -class xgl_device_create_info_struct_wrapper +class xgl_memory_ref_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_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_device_create_info_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; } - 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_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_DEVICE_CREATE_INFO m_struct; - const XGL_DEVICE_CREATE_INFO* 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(); @@ -602,35 +595,29 @@ private: //class declaration -class xgl_image_resolve_struct_wrapper +class xgl_format_properties_struct_wrapper { public: - xgl_image_resolve_struct_wrapper(); - xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct); - xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct); + 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_image_resolve_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_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; } - void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; } - XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; } - void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; } - XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; } - void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; } - XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; } - void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; } - XGL_EXTENT2D get_extent() { return m_struct.extent; } - void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; } + 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_IMAGE_RESOLVE m_struct; - const XGL_IMAGE_RESOLVE* 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(); @@ -639,32 +626,47 @@ private: //class declaration -class xgl_image_view_attach_info_struct_wrapper +class xgl_pipeline_statistics_data_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_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_image_view_attach_info_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; } - 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; } + 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_IMAGE_VIEW_ATTACH_INFO m_struct; - const XGL_IMAGE_VIEW_ATTACH_INFO* 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(); @@ -673,30 +675,31 @@ private: //class declaration -class xgl_fence_create_info_struct_wrapper +class xgl_alloc_callbacks_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_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_fence_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_FLAGS get_flags() { return m_struct.flags; } - void set_flags(XGL_FLAGS inValue) { m_struct.flags = 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_FENCE_CREATE_INFO m_struct; - const XGL_FENCE_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(); @@ -705,14 +708,14 @@ private: //class declaration -class xgl_dynamic_rs_state_create_info_struct_wrapper +class xgl_pipeline_cb_state_create_info_struct_wrapper { public: - xgl_dynamic_rs_state_create_info_struct_wrapper(); - xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct); - xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct); + 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_dynamic_rs_state_create_info_struct_wrapper(); + virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -722,23 +725,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; } - 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; } + 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_DYNAMIC_RS_STATE_CREATE_INFO m_struct; - const XGL_DYNAMIC_RS_STATE_CREATE_INFO* 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(); @@ -747,31 +746,33 @@ private: //class declaration -class xgl_buffer_copy_struct_wrapper +class xgl_draw_indirect_cmd_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_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_buffer_copy_struct_wrapper(); + 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; } - 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; } + 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_BUFFER_COPY m_struct; - const XGL_BUFFER_COPY* 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(); @@ -780,29 +781,42 @@ private: //class declaration -class xgl_color_attachment_bind_info_struct_wrapper +class xgl_color_attachment_view_create_info_struct_wrapper { public: - xgl_color_attachment_bind_info_struct_wrapper(); - xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct); - xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct); + xgl_color_attachment_view_create_info_struct_wrapper(); + xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct); + xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct); - virtual ~xgl_color_attachment_bind_info_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_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_STRUCTURE_TYPE get_sType() { return m_struct.sType; } + void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } + const void* get_pNext() { return m_struct.pNext; } + XGL_IMAGE get_image() { return m_struct.image; } + void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; } + XGL_FORMAT get_format() { return m_struct.format; } + void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; } + uint32_t get_mipLevel() { return m_struct.mipLevel; } + void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; } + uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; } + void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; } + uint32_t get_arraySize() { return m_struct.arraySize; } + void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; } + XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; } + void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; } + XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; } + void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; } private: - XGL_COLOR_ATTACHMENT_BIND_INFO m_struct; - const XGL_COLOR_ATTACHMENT_BIND_INFO* 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(); @@ -811,42 +825,43 @@ private: //class declaration -class xgl_buffer_view_create_info_struct_wrapper +class xgl_pipeline_cb_attachment_state_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_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_buffer_view_create_info_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_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; } + 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_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_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_BUFFER_VIEW_CREATE_INFO m_struct; - const XGL_BUFFER_VIEW_CREATE_INFO* 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(); @@ -855,30 +870,29 @@ private: //class declaration -class xgl_queue_semaphore_open_info_struct_wrapper +class xgl_vertex_input_binding_description_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_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_queue_semaphore_open_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_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; } - void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = 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_QUEUE_SEMAPHORE_OPEN_INFO m_struct; - const XGL_QUEUE_SEMAPHORE_OPEN_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(); @@ -887,14 +901,14 @@ private: //class declaration -class xgl_pipeline_cb_state_create_info_struct_wrapper +class xgl_pipeline_shader_stage_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_pipeline_shader_stage_create_info_struct_wrapper(); + xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct); + xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct); - virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper(); + virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -904,19 +918,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_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_PIPELINE_SHADER get_shader() { return m_struct.shader; } + void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; } private: - XGL_PIPELINE_CB_STATE_CREATE_INFO m_struct; - const XGL_PIPELINE_CB_STATE_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(); @@ -925,14 +933,14 @@ private: //class declaration -class xgl_dynamic_cb_state_create_info_struct_wrapper +class xgl_fence_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_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_dynamic_cb_state_create_info_struct_wrapper(); + virtual ~xgl_fence_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -942,11 +950,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; } private: - XGL_DYNAMIC_CB_STATE_CREATE_INFO m_struct; - const XGL_DYNAMIC_CB_STATE_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(); @@ -955,27 +965,39 @@ private: //class declaration -class xgl_buffer_memory_requirements_struct_wrapper +class xgl_framebuffer_create_info_struct_wrapper { public: - xgl_buffer_memory_requirements_struct_wrapper(); - xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct); - xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct); + 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_buffer_memory_requirements_struct_wrapper(); + virtual ~xgl_framebuffer_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - XGL_FLAGS get_usage() { return m_struct.usage; } - void set_usage(XGL_FLAGS inValue) { m_struct.usage = 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_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_BUFFER_MEMORY_REQUIREMENTS m_struct; - const XGL_BUFFER_MEMORY_REQUIREMENTS* 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(); @@ -984,28 +1006,29 @@ private: //class declaration -class xgl_sampler_image_view_info_struct_wrapper +class xgl_extent2d_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_extent2d_struct_wrapper(); + xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct); + xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct); - virtual ~xgl_sampler_image_view_info_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_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; } + 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_SAMPLER_IMAGE_VIEW_INFO m_struct; - const XGL_SAMPLER_IMAGE_VIEW_INFO* m_origStructAddr; + XGL_EXTENT2D m_struct; + const XGL_EXTENT2D* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -1014,14 +1037,14 @@ private: //class declaration -class xgl_descriptor_set_layout_create_info_struct_wrapper +class xgl_compute_pipeline_create_info_struct_wrapper { public: - xgl_descriptor_set_layout_create_info_struct_wrapper(); - xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct); - xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct); + 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_descriptor_set_layout_create_info_struct_wrapper(); + virtual ~xgl_compute_pipeline_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1031,19 +1054,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_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; } + 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_DESCRIPTOR_SET_LAYOUT_CREATE_INFO m_struct; - const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* 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(); @@ -1052,34 +1079,35 @@ private: //class declaration -class xgl_event_wait_info_struct_wrapper +class xgl_image_subresource_range_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_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_event_wait_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; } - 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; } + 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_EVENT_WAIT_INFO m_struct; - const XGL_EVENT_WAIT_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(); @@ -1088,14 +1116,14 @@ private: //class declaration -class xgl_descriptor_region_create_info_struct_wrapper +class xgl_pipeline_tess_state_create_info_struct_wrapper { public: - xgl_descriptor_region_create_info_struct_wrapper(); - xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct); - xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct); + 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_descriptor_region_create_info_struct_wrapper(); + virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1105,13 +1133,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_count() { return m_struct.count; } - void set_count(uint32_t inValue) { m_struct.count = 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_DESCRIPTOR_REGION_CREATE_INFO m_struct; - const XGL_DESCRIPTOR_REGION_CREATE_INFO* m_origStructAddr; + 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(); @@ -1120,36 +1152,29 @@ private: //class declaration -class xgl_memory_alloc_info_struct_wrapper +class xgl_offset2d_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_offset2d_struct_wrapper(); + xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct); + xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct); - virtual ~xgl_memory_alloc_info_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; } - 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; } + 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_MEMORY_ALLOC_INFO m_struct; - const XGL_MEMORY_ALLOC_INFO* m_origStructAddr; + XGL_OFFSET2D m_struct; + const XGL_OFFSET2D* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -1158,14 +1183,14 @@ private: //class declaration -class xgl_memory_open_info_struct_wrapper +class xgl_queue_semaphore_create_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_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_memory_open_info_struct_wrapper(); + virtual ~xgl_queue_semaphore_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1175,13 +1200,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_sharedMem() { return m_struct.sharedMem; } - void set_sharedMem(XGL_GPU_MEMORY inValue) { m_struct.sharedMem = inValue; } + 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_MEMORY_OPEN_INFO m_struct; - const XGL_MEMORY_OPEN_INFO* 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(); @@ -1190,32 +1217,25 @@ private: //class declaration -class xgl_graphics_pipeline_create_info_struct_wrapper +class xgl_clear_color_value_struct_wrapper { public: - xgl_graphics_pipeline_create_info_struct_wrapper(); - xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct); - xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct); + 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_graphics_pipeline_create_info_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_STRUCTURE_TYPE get_sType() { return m_struct.sType; } - void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } - const void* get_pNext() { return m_struct.pNext; } - XGL_FLAGS get_flags() { return m_struct.flags; } - void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; } - XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; } - void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; } private: - XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct; - const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr; + 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(); @@ -1224,14 +1244,14 @@ private: //class declaration -class xgl_pipeline_shader_stage_create_info_struct_wrapper +class xgl_buffer_memory_barrier_struct_wrapper { public: - xgl_pipeline_shader_stage_create_info_struct_wrapper(); - xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct); - xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct); - - virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper(); + xgl_buffer_memory_barrier_struct_wrapper(); + xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct); + xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct); + + virtual ~xgl_buffer_memory_barrier_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1241,13 +1261,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_PIPELINE_SHADER get_shader() { return m_struct.shader; } - void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = 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_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct; - const XGL_PIPELINE_SHADER_STAGE_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(); @@ -1296,14 +1324,14 @@ private: //class declaration -class xgl_pipeline_barrier_struct_wrapper +class xgl_pipeline_rs_state_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_pipeline_rs_state_create_info_struct_wrapper(); + xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct); + xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct); - virtual ~xgl_pipeline_barrier_struct_wrapper(); + virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1313,17 +1341,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_PIPELINE_BARRIER m_struct; - const XGL_PIPELINE_BARRIER* 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(); @@ -1332,14 +1370,14 @@ private: //class declaration -class xgl_memory_barrier_struct_wrapper +class xgl_image_create_info_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_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_memory_barrier_struct_wrapper(); + virtual ~xgl_image_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1349,15 +1387,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_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_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_MEMORY_BARRIER m_struct; - const XGL_MEMORY_BARRIER* 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(); @@ -1366,14 +1418,14 @@ private: //class declaration -class xgl_pipeline_ia_state_create_info_struct_wrapper +class xgl_update_images_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_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_pipeline_ia_state_create_info_struct_wrapper(); + virtual ~xgl_update_images_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1383,19 +1435,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_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; } + 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_IA_STATE_CREATE_INFO m_struct; - const XGL_PIPELINE_IA_STATE_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(); @@ -1404,43 +1454,30 @@ private: //class declaration -class xgl_pipeline_cb_attachment_state_struct_wrapper +class xgl_cmd_buffer_begin_info_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_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_pipeline_cb_attachment_state_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; } - 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_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_PIPELINE_CB_ATTACHMENT_STATE m_struct; - const XGL_PIPELINE_CB_ATTACHMENT_STATE* 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(); @@ -1449,14 +1486,14 @@ private: //class declaration -class xgl_cmd_buffer_create_info_struct_wrapper +class xgl_image_view_create_info_struct_wrapper { public: - xgl_cmd_buffer_create_info_struct_wrapper(); - xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct); - xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct); + 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_cmd_buffer_create_info_struct_wrapper(); + virtual ~xgl_image_view_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1466,15 +1503,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_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_IMAGE get_image() { return m_struct.image; } + void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; } + XGL_IMAGE_VIEW_TYPE get_viewType() { return m_struct.viewType; } + void set_viewType(XGL_IMAGE_VIEW_TYPE inValue) { m_struct.viewType = inValue; } + XGL_FORMAT get_format() { return m_struct.format; } + void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; } + XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; } + void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; } + XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; } + void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; } + float get_minLod() { return m_struct.minLod; } + void set_minLod(float inValue) { m_struct.minLod = inValue; } private: - XGL_CMD_BUFFER_CREATE_INFO m_struct; - const XGL_CMD_BUFFER_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(); @@ -1483,14 +1528,14 @@ private: //class declaration -class xgl_application_info_struct_wrapper +class xgl_graphics_pipeline_create_info_struct_wrapper { public: - xgl_application_info_struct_wrapper(); - xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct); - xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct); + xgl_graphics_pipeline_create_info_struct_wrapper(); + xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct); + xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct); - virtual ~xgl_application_info_struct_wrapper(); + virtual ~xgl_graphics_pipeline_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1500,19 +1545,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; } - const char* get_pAppName() { return m_struct.pAppName; } - uint32_t get_appVersion() { return m_struct.appVersion; } - void set_appVersion(uint32_t inValue) { m_struct.appVersion = inValue; } - const char* get_pEngineName() { return m_struct.pEngineName; } - uint32_t get_engineVersion() { return m_struct.engineVersion; } - void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; } - uint32_t get_apiVersion() { return m_struct.apiVersion; } - void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; } + XGL_FLAGS get_flags() { return m_struct.flags; } + void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; } + XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; } + void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; } private: - XGL_APPLICATION_INFO m_struct; - const XGL_APPLICATION_INFO* m_origStructAddr; + XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct; + const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -1521,44 +1562,29 @@ private: //class declaration -class xgl_pipeline_rs_state_create_info_struct_wrapper +class xgl_rect_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_rect_struct_wrapper(); + xgl_rect_struct_wrapper(XGL_RECT* pInStruct); + xgl_rect_struct_wrapper(const XGL_RECT* pInStruct); - virtual ~xgl_pipeline_rs_state_create_info_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_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; } + 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_PIPELINE_RS_STATE_CREATE_INFO m_struct; - const XGL_PIPELINE_RS_STATE_CREATE_INFO* m_origStructAddr; + XGL_RECT m_struct; + const XGL_RECT* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -1567,14 +1593,14 @@ private: //class declaration -class xgl_color_attachment_view_create_info_struct_wrapper +class xgl_cmd_buffer_graphics_begin_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_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_color_attachment_view_create_info_struct_wrapper(); + virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1584,25 +1610,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_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_RENDER_PASS get_renderPass() { return m_struct.renderPass; } + void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = inValue; } private: - XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct; - const XGL_COLOR_ATTACHMENT_VIEW_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(); @@ -1611,31 +1625,29 @@ private: //class declaration -class xgl_image_memory_bind_info_struct_wrapper +class xgl_device_queue_create_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_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_image_memory_bind_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_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; } + 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_IMAGE_MEMORY_BIND_INFO m_struct; - const XGL_IMAGE_MEMORY_BIND_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(); @@ -1644,31 +1656,30 @@ private: //class declaration -class xgl_image_subresource_struct_wrapper +class xgl_memory_open_info_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_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_image_subresource_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_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_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_IMAGE_SUBRESOURCE m_struct; - const XGL_IMAGE_SUBRESOURCE* 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(); @@ -1677,33 +1688,36 @@ private: //class declaration -class xgl_draw_indirect_cmd_struct_wrapper +class xgl_update_as_copy_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_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_draw_indirect_cmd_struct_wrapper(); + 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; } - 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; } + 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_DRAW_INDIRECT_CMD m_struct; - const XGL_DRAW_INDIRECT_CMD* 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(); @@ -1712,40 +1726,35 @@ private: //class declaration -class xgl_image_view_create_info_struct_wrapper +class xgl_image_copy_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_image_copy_struct_wrapper(); + xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct); + xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct); - virtual ~xgl_image_view_create_info_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_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_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; } + void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; } + XGL_OFFSET3D get_srcOffset() { return m_struct.srcOffset; } + void set_srcOffset(XGL_OFFSET3D inValue) { m_struct.srcOffset = inValue; } + XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; } + void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; } + XGL_OFFSET3D get_destOffset() { return m_struct.destOffset; } + void set_destOffset(XGL_OFFSET3D inValue) { m_struct.destOffset = inValue; } + XGL_EXTENT3D get_extent() { return m_struct.extent; } + void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; } private: - XGL_IMAGE_VIEW_CREATE_INFO m_struct; - const XGL_IMAGE_VIEW_CREATE_INFO* 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(); @@ -1754,30 +1763,35 @@ private: //class declaration -class xgl_cmd_buffer_begin_info_struct_wrapper +class xgl_image_resolve_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_image_resolve_struct_wrapper(); + xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct); + xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct); - virtual ~xgl_cmd_buffer_begin_info_struct_wrapper(); + virtual ~xgl_image_resolve_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - XGL_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_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; } + void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; } + XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; } + void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; } + XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; } + void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; } + XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; } + void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; } + XGL_EXTENT2D get_extent() { return m_struct.extent; } + void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; } private: - XGL_CMD_BUFFER_BEGIN_INFO m_struct; - const XGL_CMD_BUFFER_BEGIN_INFO* m_origStructAddr; + XGL_IMAGE_RESOLVE m_struct; + const XGL_IMAGE_RESOLVE* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -1786,35 +1800,29 @@ private: //class declaration -class xgl_image_copy_struct_wrapper +class xgl_color_attachment_bind_info_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_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_image_copy_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_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_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_IMAGE_COPY m_struct; - const XGL_IMAGE_COPY* 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(); @@ -1823,14 +1831,14 @@ private: //class declaration -class xgl_pipeline_vp_state_create_info_struct_wrapper +class xgl_dynamic_ds_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); + 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_pipeline_vp_state_create_info_struct_wrapper(); + virtual ~xgl_dynamic_ds_state_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1840,17 +1848,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_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; } + 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_PIPELINE_VP_STATE_CREATE_INFO m_struct; - const XGL_PIPELINE_VP_STATE_CREATE_INFO* 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(); @@ -1901,30 +1915,45 @@ private: //class declaration -class xgl_physical_gpu_memory_properties_struct_wrapper +class xgl_pipeline_ds_state_create_info_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_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_physical_gpu_memory_properties_struct_wrapper(); + virtual ~xgl_pipeline_ds_state_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - bool32_t get_supportsMigration() { return m_struct.supportsMigration; } - void set_supportsMigration(bool32_t inValue) { m_struct.supportsMigration = inValue; } - bool32_t get_supportsPinning() { return m_struct.supportsPinning; } - void set_supportsPinning(bool32_t inValue) { m_struct.supportsPinning = inValue; } - - -private: - XGL_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct; - const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr; - uint32_t m_indent; + XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; } + void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } + const void* get_pNext() { return m_struct.pNext; } + XGL_FORMAT get_format() { return m_struct.format; } + void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; } + bool32_t get_depthTestEnable() { return m_struct.depthTestEnable; } + void set_depthTestEnable(bool32_t inValue) { m_struct.depthTestEnable = inValue; } + bool32_t get_depthWriteEnable() { return m_struct.depthWriteEnable; } + void set_depthWriteEnable(bool32_t inValue) { m_struct.depthWriteEnable = inValue; } + XGL_COMPARE_FUNC get_depthFunc() { return m_struct.depthFunc; } + void set_depthFunc(XGL_COMPARE_FUNC inValue) { m_struct.depthFunc = inValue; } + bool32_t get_depthBoundsEnable() { return m_struct.depthBoundsEnable; } + void set_depthBoundsEnable(bool32_t inValue) { m_struct.depthBoundsEnable = inValue; } + bool32_t get_stencilTestEnable() { return m_struct.stencilTestEnable; } + void set_stencilTestEnable(bool32_t inValue) { m_struct.stencilTestEnable = inValue; } + XGL_STENCIL_OP_STATE get_front() { return m_struct.front; } + void set_front(XGL_STENCIL_OP_STATE inValue) { m_struct.front = inValue; } + XGL_STENCIL_OP_STATE get_back() { return m_struct.back; } + void set_back(XGL_STENCIL_OP_STATE inValue) { m_struct.back = inValue; } + + +private: + XGL_PIPELINE_DS_STATE_CREATE_INFO m_struct; + const XGL_PIPELINE_DS_STATE_CREATE_INFO* m_origStructAddr; + uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -1932,14 +1961,14 @@ private: //class declaration -class xgl_memory_alloc_buffer_info_struct_wrapper +class xgl_pipeline_barrier_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_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_memory_alloc_buffer_info_struct_wrapper(); + virtual ~xgl_pipeline_barrier_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -1949,13 +1978,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_FLAGS get_usage() { return m_struct.usage; } - void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; } + uint32_t get_eventCount() { return m_struct.eventCount; } + void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; } + XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; } + void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; } + uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; } + void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; } private: - XGL_MEMORY_ALLOC_BUFFER_INFO m_struct; - const XGL_MEMORY_ALLOC_BUFFER_INFO* 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(); @@ -1964,40 +1997,29 @@ private: //class declaration -class xgl_compute_pipeline_create_info_struct_wrapper +class xgl_physical_gpu_memory_properties_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_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_compute_pipeline_create_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_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; } + 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_COMPUTE_PIPELINE_CREATE_INFO m_struct; - const XGL_COMPUTE_PIPELINE_CREATE_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(); @@ -2006,33 +2028,34 @@ private: //class declaration -class xgl_channel_mapping_struct_wrapper +class xgl_memory_alloc_image_info_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_memory_alloc_image_info_struct_wrapper(); + xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct); + xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct); - virtual ~xgl_channel_mapping_struct_wrapper(); + virtual ~xgl_memory_alloc_image_info_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - XGL_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; } + XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; } + void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } + const void* get_pNext() { return m_struct.pNext; } + XGL_FLAGS get_usage() { return m_struct.usage; } + void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; } + XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; } + void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; } + uint32_t get_samples() { return m_struct.samples; } + void set_samples(uint32_t inValue) { m_struct.samples = inValue; } private: - XGL_CHANNEL_MAPPING m_struct; - const XGL_CHANNEL_MAPPING* m_origStructAddr; + XGL_MEMORY_ALLOC_IMAGE_INFO m_struct; + const XGL_MEMORY_ALLOC_IMAGE_INFO* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -2041,27 +2064,32 @@ private: //class declaration -class xgl_peer_image_open_info_struct_wrapper +class xgl_update_sampler_textures_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_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_peer_image_open_info_struct_wrapper(); + virtual ~xgl_update_sampler_textures_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - XGL_IMAGE get_originalImage() { return m_struct.originalImage; } - void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = 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_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_PEER_IMAGE_OPEN_INFO m_struct; - const XGL_PEER_IMAGE_OPEN_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(); @@ -2070,14 +2098,14 @@ private: //class declaration -class xgl_dynamic_vp_state_create_info_struct_wrapper +class xgl_peer_memory_open_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_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_dynamic_vp_state_create_info_struct_wrapper(); + virtual ~xgl_peer_memory_open_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2087,13 +2115,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_viewportAndScissorCount() { return m_struct.viewportAndScissorCount; } - void set_viewportAndScissorCount(uint32_t inValue) { m_struct.viewportAndScissorCount = inValue; } + XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; } + void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; } private: - XGL_DYNAMIC_VP_STATE_CREATE_INFO m_struct; - const XGL_DYNAMIC_VP_STATE_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(); @@ -2102,35 +2130,29 @@ private: //class declaration -class xgl_physical_gpu_performance_struct_wrapper +class xgl_descriptor_type_count_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_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_physical_gpu_performance_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; } - 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_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_PHYSICAL_GPU_PERFORMANCE m_struct; - const XGL_PHYSICAL_GPU_PERFORMANCE* 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(); @@ -2139,14 +2161,47 @@ private: //class declaration -class xgl_render_pass_create_info_struct_wrapper +class xgl_dispatch_indirect_cmd_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_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_render_pass_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; } + uint32_t get_x() { return m_struct.x; } + void set_x(uint32_t inValue) { m_struct.x = inValue; } + uint32_t get_y() { return m_struct.y; } + void set_y(uint32_t inValue) { m_struct.y = inValue; } + uint32_t get_z() { return m_struct.z; } + void set_z(uint32_t inValue) { m_struct.z = inValue; } + + +private: + XGL_DISPATCH_INDIRECT_CMD m_struct; + const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr; + uint32_t m_indent; + const char m_dummy_prefix; + void display_struct_members(); + +}; + + +//class declaration +class xgl_descriptor_region_create_info_struct_wrapper +{ +public: + xgl_descriptor_region_create_info_struct_wrapper(); + xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct); + xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct); + + virtual ~xgl_descriptor_region_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2156,29 +2211,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_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_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_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(); @@ -2226,14 +2265,14 @@ private: //class declaration -class xgl_dynamic_ds_state_create_info_struct_wrapper +class xgl_depth_stencil_view_create_info_struct_wrapper { public: - xgl_dynamic_ds_state_create_info_struct_wrapper(); - xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct); - xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct); + 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_dynamic_ds_state_create_info_struct_wrapper(); + virtual ~xgl_depth_stencil_view_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2243,23 +2282,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; } - 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 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_DYNAMIC_DS_STATE_CREATE_INFO m_struct; - const XGL_DYNAMIC_DS_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(); @@ -2268,14 +2309,14 @@ private: //class declaration -class xgl_buffer_create_info_struct_wrapper +class xgl_query_pool_create_info_struct_wrapper { public: - xgl_buffer_create_info_struct_wrapper(); - xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct); - xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct); + 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_buffer_create_info_struct_wrapper(); + virtual ~xgl_query_pool_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2285,17 +2326,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_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_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_BUFFER_CREATE_INFO m_struct; - const XGL_BUFFER_CREATE_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(); @@ -2304,14 +2343,14 @@ private: //class declaration -class xgl_cmd_buffer_graphics_begin_info_struct_wrapper +class xgl_cmd_buffer_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_cmd_buffer_create_info_struct_wrapper(); + xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct); + xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct); - virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper(); + virtual ~xgl_cmd_buffer_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2321,13 +2360,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_RENDER_PASS get_renderPass() { return m_struct.renderPass; } - void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = 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_CMD_BUFFER_GRAPHICS_BEGIN_INFO m_struct; - const XGL_CMD_BUFFER_GRAPHICS_BEGIN_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(); @@ -2336,29 +2377,29 @@ private: //class declaration -class xgl_rect_struct_wrapper +class xgl_depth_stencil_bind_info_struct_wrapper { public: - xgl_rect_struct_wrapper(); - xgl_rect_struct_wrapper(XGL_RECT* pInStruct); - xgl_rect_struct_wrapper(const XGL_RECT* 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_rect_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; } - 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_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_RECT m_struct; - const XGL_RECT* 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(); @@ -2367,38 +2408,35 @@ private: //class declaration -class xgl_buffer_memory_barrier_struct_wrapper +class xgl_memory_requirements_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_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_buffer_memory_barrier_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; } - 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; } + 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_BUFFER_MEMORY_BARRIER m_struct; - const XGL_BUFFER_MEMORY_BARRIER* 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(); @@ -2407,14 +2445,14 @@ private: //class declaration -class xgl_pipeline_ds_state_create_info_struct_wrapper +class xgl_queue_semaphore_open_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_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_pipeline_ds_state_create_info_struct_wrapper(); + virtual ~xgl_queue_semaphore_open_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2424,27 +2462,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_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_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; } + void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = inValue; } private: - XGL_PIPELINE_DS_STATE_CREATE_INFO m_struct; - const XGL_PIPELINE_DS_STATE_CREATE_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(); @@ -2453,29 +2477,32 @@ private: //class declaration -class xgl_descriptor_type_count_struct_wrapper +class xgl_memory_barrier_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_barrier_struct_wrapper(); + xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct); + xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct); - virtual ~xgl_descriptor_type_count_struct_wrapper(); + virtual ~xgl_memory_barrier_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - XGL_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_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_DESCRIPTOR_TYPE_COUNT m_struct; - const XGL_DESCRIPTOR_TYPE_COUNT* 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(); @@ -2484,32 +2511,35 @@ private: //class declaration -class xgl_update_sampler_textures_struct_wrapper +class xgl_physical_gpu_performance_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_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_update_sampler_textures_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_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; } + 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_UPDATE_SAMPLER_TEXTURES m_struct; - const XGL_UPDATE_SAMPLER_TEXTURES* 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(); @@ -2518,32 +2548,33 @@ private: //class declaration -class xgl_query_pool_create_info_struct_wrapper +class xgl_channel_mapping_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_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_query_pool_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; } - 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_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_QUERY_POOL_CREATE_INFO m_struct; - const XGL_QUERY_POOL_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(); @@ -2552,61 +2583,29 @@ private: //class declaration -class xgl_event_create_info_struct_wrapper +class xgl_clear_color_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_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_event_create_info_struct_wrapper(); - - void display_txt(); - void display_single_txt(); - void display_full_txt(); - - void set_indent(uint32_t indent) { m_indent = indent; } - XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; } - void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } - const void* get_pNext() { return m_struct.pNext; } - XGL_FLAGS get_flags() { return m_struct.flags; } - void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; } - - -private: - XGL_EVENT_CREATE_INFO m_struct; - const XGL_EVENT_CREATE_INFO* m_origStructAddr; - uint32_t m_indent; - const char m_dummy_prefix; - void display_struct_members(); - -}; - - -//class declaration -class xgl_offset2d_struct_wrapper -{ -public: - xgl_offset2d_struct_wrapper(); - xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct); - xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct); - - virtual ~xgl_offset2d_struct_wrapper(); + 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; } - 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_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_OFFSET2D m_struct; - const XGL_OFFSET2D* 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(); @@ -2615,14 +2614,14 @@ private: //class declaration -class xgl_update_buffers_struct_wrapper +class xgl_dynamic_cb_state_create_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_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_update_buffers_struct_wrapper(); + virtual ~xgl_dynamic_cb_state_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2632,17 +2631,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_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; } - void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; } - uint32_t get_index() { return m_struct.index; } - void set_index(uint32_t inValue) { m_struct.index = inValue; } - uint32_t get_count() { return m_struct.count; } - void set_count(uint32_t inValue) { m_struct.count = inValue; } private: - XGL_UPDATE_BUFFERS m_struct; - const XGL_UPDATE_BUFFERS* m_origStructAddr; + 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(); @@ -2651,29 +2644,42 @@ private: //class declaration -class xgl_memory_ref_struct_wrapper +class xgl_buffer_view_create_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_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_memory_ref_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; } - 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_STRUCTURE_TYPE get_sType() { return m_struct.sType; } + void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } + const void* get_pNext() { return m_struct.pNext; } + XGL_BUFFER get_buffer() { return m_struct.buffer; } + void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; } + XGL_BUFFER_VIEW_TYPE get_viewType() { return m_struct.viewType; } + void set_viewType(XGL_BUFFER_VIEW_TYPE inValue) { m_struct.viewType = inValue; } + XGL_GPU_SIZE get_stride() { return m_struct.stride; } + void set_stride(XGL_GPU_SIZE inValue) { m_struct.stride = inValue; } + XGL_FORMAT get_format() { return m_struct.format; } + void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; } + XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; } + void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; } + XGL_GPU_SIZE get_offset() { return m_struct.offset; } + void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; } + XGL_GPU_SIZE get_range() { return m_struct.range; } + void set_range(XGL_GPU_SIZE inValue) { m_struct.range = inValue; } private: - XGL_MEMORY_REF m_struct; - const XGL_MEMORY_REF* 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(); @@ -2682,14 +2688,14 @@ private: //class declaration -class xgl_buffer_view_attach_info_struct_wrapper +class xgl_sampler_create_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_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_buffer_view_attach_info_struct_wrapper(); + virtual ~xgl_sampler_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2699,13 +2705,35 @@ 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_VIEW get_view() { return m_struct.view; } - void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; } + 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_BUFFER_VIEW_ATTACH_INFO m_struct; - const XGL_BUFFER_VIEW_ATTACH_INFO* 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(); @@ -2714,14 +2742,14 @@ private: //class declaration -class xgl_pipeline_vertex_input_create_info_struct_wrapper +class xgl_event_wait_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); + 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_pipeline_vertex_input_create_info_struct_wrapper(); + virtual ~xgl_event_wait_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2731,15 +2759,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_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; } + uint32_t get_eventCount() { return m_struct.eventCount; } + void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; } + XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; } + void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; } + uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; } + void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; } private: - XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_struct; - const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* 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(); @@ -2748,27 +2778,33 @@ private: //class declaration -class xgl_gpu_compatibility_info_struct_wrapper +class xgl_buffer_image_copy_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_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_gpu_compatibility_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_FLAGS get_compatibilityFlags() { return m_struct.compatibilityFlags; } - void set_compatibilityFlags(XGL_FLAGS inValue) { m_struct.compatibilityFlags = 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_GPU_COMPATIBILITY_INFO m_struct; - const XGL_GPU_COMPATIBILITY_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(); @@ -2777,14 +2813,14 @@ private: //class declaration -class xgl_shader_create_info_struct_wrapper +class xgl_event_create_info_struct_wrapper { public: - xgl_shader_create_info_struct_wrapper(); - xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct); - xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct); + 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_shader_create_info_struct_wrapper(); + virtual ~xgl_event_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2794,16 +2830,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; } private: - XGL_SHADER_CREATE_INFO m_struct; - const XGL_SHADER_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(); @@ -2812,31 +2845,53 @@ private: //class declaration -class xgl_offset3d_struct_wrapper +class xgl_physical_gpu_properties_struct_wrapper { public: - xgl_offset3d_struct_wrapper(); - xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct); - xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct); + xgl_physical_gpu_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_offset3d_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; } - 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; } + 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_OFFSET3D m_struct; - const XGL_OFFSET3D* 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(); @@ -2845,14 +2900,14 @@ private: //class declaration -class xgl_layer_create_info_struct_wrapper +class xgl_image_view_attach_info_struct_wrapper { public: - xgl_layer_create_info_struct_wrapper(); - xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct); - xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct); + 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_layer_create_info_struct_wrapper(); + virtual ~xgl_image_view_attach_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2862,13 +2917,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_layerCount() { return m_struct.layerCount; } - void set_layerCount(uint32_t inValue) { m_struct.layerCount = 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_LAYER_CREATE_INFO m_struct; - const XGL_LAYER_CREATE_INFO* 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(); @@ -2877,14 +2934,14 @@ private: //class declaration -class xgl_depth_stencil_view_create_info_struct_wrapper +class xgl_memory_alloc_buffer_info_struct_wrapper { public: - xgl_depth_stencil_view_create_info_struct_wrapper(); - xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct); - xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct); + 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_depth_stencil_view_create_info_struct_wrapper(); + virtual ~xgl_memory_alloc_buffer_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -2894,25 +2951,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_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; } + XGL_FLAGS get_usage() { return m_struct.usage; } + void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; } private: - XGL_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct; - const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr; + XGL_MEMORY_ALLOC_BUFFER_INFO m_struct; + const XGL_MEMORY_ALLOC_BUFFER_INFO* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -2921,29 +2966,64 @@ private: //class declaration -class xgl_depth_stencil_bind_info_struct_wrapper +class xgl_buffer_copy_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_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_depth_stencil_bind_info_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; } - 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; } + 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_DEPTH_STENCIL_BIND_INFO m_struct; - const XGL_DEPTH_STENCIL_BIND_INFO* 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(); + +}; + + +//class declaration +class xgl_image_memory_bind_info_struct_wrapper +{ +public: + xgl_image_memory_bind_info_struct_wrapper(); + xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct); + xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct); + + virtual ~xgl_image_memory_bind_info_struct_wrapper(); + + void display_txt(); + void display_single_txt(); + void display_full_txt(); + + void set_indent(uint32_t indent) { m_indent = indent; } + XGL_IMAGE_SUBRESOURCE get_subresource() { return m_struct.subresource; } + void set_subresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.subresource = inValue; } + XGL_OFFSET3D get_offset() { return m_struct.offset; } + void set_offset(XGL_OFFSET3D inValue) { m_struct.offset = inValue; } + XGL_EXTENT3D get_extent() { return m_struct.extent; } + void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; } + + +private: + XGL_IMAGE_MEMORY_BIND_INFO m_struct; + const XGL_IMAGE_MEMORY_BIND_INFO* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -2985,35 +3065,31 @@ private: //class declaration -class xgl_image_subresource_range_struct_wrapper +class xgl_pipeline_shader_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_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_image_subresource_range_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_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_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_IMAGE_SUBRESOURCE_RANGE m_struct; - const XGL_IMAGE_SUBRESOURCE_RANGE* 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(); @@ -3022,34 +3098,31 @@ private: //class declaration -class xgl_update_images_struct_wrapper +class xgl_offset3d_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_offset3d_struct_wrapper(); + xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct); + xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct); - virtual ~xgl_update_images_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_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; } + 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_UPDATE_IMAGES m_struct; - const XGL_UPDATE_IMAGES* m_origStructAddr; + XGL_OFFSET3D m_struct; + const XGL_OFFSET3D* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -3058,31 +3131,30 @@ private: //class declaration -class xgl_dispatch_indirect_cmd_struct_wrapper +class xgl_buffer_view_attach_info_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_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_dispatch_indirect_cmd_struct_wrapper(); + virtual ~xgl_buffer_view_attach_info_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - 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_STRUCTURE_TYPE get_sType() { return m_struct.sType; } + void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } + const void* get_pNext() { return m_struct.pNext; } + XGL_BUFFER_VIEW get_view() { return m_struct.view; } + void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; } private: - XGL_DISPATCH_INDIRECT_CMD m_struct; - const XGL_DISPATCH_INDIRECT_CMD* 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(); @@ -3124,25 +3196,28 @@ private: //class declaration -class xgl_clear_color_value_struct_wrapper +class xgl_sampler_image_view_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_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_clear_color_value_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_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_CLEAR_COLOR_VALUE m_struct; - const XGL_CLEAR_COLOR_VALUE* 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(); @@ -3151,34 +3226,31 @@ private: //class declaration -class xgl_memory_alloc_image_info_struct_wrapper +class xgl_image_subresource_struct_wrapper { public: - xgl_memory_alloc_image_info_struct_wrapper(); - xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct); - xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct); + 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_memory_alloc_image_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_STRUCTURE_TYPE get_sType() { return m_struct.sType; } - void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; } - const void* get_pNext() { return m_struct.pNext; } - XGL_FLAGS get_usage() { return m_struct.usage; } - void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; } - XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; } - void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; } - uint32_t get_samples() { return m_struct.samples; } - void set_samples(uint32_t inValue) { m_struct.samples = inValue; } + 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_MEMORY_ALLOC_IMAGE_INFO m_struct; - const XGL_MEMORY_ALLOC_IMAGE_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(); @@ -3187,64 +3259,30 @@ private: //class declaration -class xgl_device_queue_create_info_struct_wrapper +class xgl_layer_create_info_struct_wrapper { public: - xgl_device_queue_create_info_struct_wrapper(); - xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct); - xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct); + 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_device_queue_create_info_struct_wrapper(); + virtual ~xgl_layer_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - 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; } + uint32_t get_layerCount() { return m_struct.layerCount; } + void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; } private: - XGL_DEVICE_QUEUE_CREATE_INFO m_struct; - const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr; - uint32_t m_indent; - const char m_dummy_prefix; - void display_struct_members(); - -}; - - -//class declaration -class xgl_stencil_op_state_struct_wrapper -{ -public: - xgl_stencil_op_state_struct_wrapper(); - xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct); - xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct); - - virtual ~xgl_stencil_op_state_struct_wrapper(); - - void display_txt(); - void display_single_txt(); - void display_full_txt(); - - void set_indent(uint32_t indent) { m_indent = indent; } - XGL_STENCIL_OP get_stencilFailOp() { return m_struct.stencilFailOp; } - void set_stencilFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilFailOp = inValue; } - XGL_STENCIL_OP get_stencilPassOp() { return m_struct.stencilPassOp; } - void set_stencilPassOp(XGL_STENCIL_OP inValue) { m_struct.stencilPassOp = inValue; } - XGL_STENCIL_OP get_stencilDepthFailOp() { return m_struct.stencilDepthFailOp; } - void set_stencilDepthFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilDepthFailOp = inValue; } - XGL_COMPARE_FUNC get_stencilFunc() { return m_struct.stencilFunc; } - void set_stencilFunc(XGL_COMPARE_FUNC inValue) { m_struct.stencilFunc = inValue; } - - -private: - XGL_STENCIL_OP_STATE m_struct; - const XGL_STENCIL_OP_STATE* m_origStructAddr; + 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(); @@ -3253,31 +3291,34 @@ private: //class declaration -class xgl_pipeline_shader_struct_wrapper +class xgl_pipeline_vp_state_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_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_shader_struct_wrapper(); + 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_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; } + 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_PIPELINE_SHADER m_struct; - const XGL_PIPELINE_SHADER* 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(); @@ -3286,14 +3327,14 @@ private: //class declaration -class xgl_queue_semaphore_create_info_struct_wrapper +class xgl_buffer_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_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_queue_semaphore_create_info_struct_wrapper(); + virtual ~xgl_buffer_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -3303,64 +3344,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_initialCount() { return m_struct.initialCount; } - void set_initialCount(uint32_t inValue) { m_struct.initialCount = 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_QUEUE_SEMAPHORE_CREATE_INFO m_struct; - const XGL_QUEUE_SEMAPHORE_CREATE_INFO* m_origStructAddr; - uint32_t m_indent; - const char m_dummy_prefix; - void display_struct_members(); - -}; - - -//class declaration -class xgl_pipeline_statistics_data_struct_wrapper -{ -public: - xgl_pipeline_statistics_data_struct_wrapper(); - xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct); - xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct); - - virtual ~xgl_pipeline_statistics_data_struct_wrapper(); - - void display_txt(); - void display_single_txt(); - void display_full_txt(); - - void set_indent(uint32_t indent) { m_indent = indent; } - uint64_t get_fsInvocations() { return m_struct.fsInvocations; } - void set_fsInvocations(uint64_t inValue) { m_struct.fsInvocations = inValue; } - uint64_t get_cPrimitives() { return m_struct.cPrimitives; } - void set_cPrimitives(uint64_t inValue) { m_struct.cPrimitives = inValue; } - uint64_t get_cInvocations() { return m_struct.cInvocations; } - void set_cInvocations(uint64_t inValue) { m_struct.cInvocations = inValue; } - uint64_t get_vsInvocations() { return m_struct.vsInvocations; } - void set_vsInvocations(uint64_t inValue) { m_struct.vsInvocations = inValue; } - uint64_t get_gsInvocations() { return m_struct.gsInvocations; } - void set_gsInvocations(uint64_t inValue) { m_struct.gsInvocations = inValue; } - uint64_t get_gsPrimitives() { return m_struct.gsPrimitives; } - void set_gsPrimitives(uint64_t inValue) { m_struct.gsPrimitives = inValue; } - uint64_t get_iaPrimitives() { return m_struct.iaPrimitives; } - void set_iaPrimitives(uint64_t inValue) { m_struct.iaPrimitives = inValue; } - uint64_t get_iaVertices() { return m_struct.iaVertices; } - void set_iaVertices(uint64_t inValue) { m_struct.iaVertices = inValue; } - uint64_t get_tcsInvocations() { return m_struct.tcsInvocations; } - void set_tcsInvocations(uint64_t inValue) { m_struct.tcsInvocations = inValue; } - uint64_t get_tesInvocations() { return m_struct.tesInvocations; } - void set_tesInvocations(uint64_t inValue) { m_struct.tesInvocations = inValue; } - uint64_t get_csInvocations() { return m_struct.csInvocations; } - void set_csInvocations(uint64_t inValue) { m_struct.csInvocations = inValue; } - - -private: - XGL_PIPELINE_STATISTICS_DATA m_struct; - const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr; + 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(); @@ -3369,31 +3363,46 @@ private: //class declaration -class xgl_vertex_input_attribute_description_struct_wrapper +class xgl_render_pass_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_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_vertex_input_attribute_description_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; } - 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; } + 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_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION m_struct; - const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* 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(); @@ -3402,29 +3411,36 @@ private: //class declaration -class xgl_vertex_input_binding_description_struct_wrapper +class xgl_descriptor_set_layout_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_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_vertex_input_binding_description_struct_wrapper(); + virtual ~xgl_descriptor_set_layout_create_info_struct_wrapper(); void display_txt(); void display_single_txt(); void display_full_txt(); void set_indent(uint32_t indent) { m_indent = indent; } - 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; } + 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_VERTEX_INPUT_BINDING_DESCRIPTION m_struct; - const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* 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(); @@ -3433,32 +3449,27 @@ private: //class declaration -class xgl_update_samplers_struct_wrapper +class xgl_gpu_compatibility_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_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_update_samplers_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; } - 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_compatibilityFlags() { return m_struct.compatibilityFlags; } + void set_compatibilityFlags(XGL_FLAGS inValue) { m_struct.compatibilityFlags = inValue; } private: - XGL_UPDATE_SAMPLERS m_struct; - const XGL_UPDATE_SAMPLERS* 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(); @@ -3467,14 +3478,14 @@ private: //class declaration -class xgl_image_create_info_struct_wrapper +class xgl_memory_alloc_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); + 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_image_create_info_struct_wrapper(); + virtual ~xgl_memory_alloc_info_struct_wrapper(); void display_txt(); void display_single_txt(); @@ -3484,29 +3495,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_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; } + 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_IMAGE_CREATE_INFO m_struct; - const XGL_IMAGE_CREATE_INFO* m_origStructAddr; + XGL_MEMORY_ALLOC_INFO m_struct; + const XGL_MEMORY_ALLOC_INFO* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); @@ -3515,34 +3516,33 @@ private: //class declaration -class xgl_pipeline_tess_state_create_info_struct_wrapper +class xgl_physical_gpu_queue_properties_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_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_pipeline_tess_state_create_info_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; } - 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; } + 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_PIPELINE_TESS_STATE_CREATE_INFO m_struct; - const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr; + XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct; + const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr; uint32_t m_indent; const char m_dummy_prefix; void display_struct_members(); -- 2.7.4